主页 / coding / 问题 / 79531052
Accepted
iRon
Asked: 2025-03-24 20:22:25 +0800 CST

解决方法 `#24898`：升级到 powershell 7.5.0 后缺少 MemberwiseClone

  • 772

我遇到了这个问题：#24898升级到 powershell 7.5.0 后，MemberwiseClone 丢失：

class MyClass {
     [string]$Name

     [object] CloneProblem() {
         return $this.MemberwiseClone()
    }
}

$obj = [MyClass]::new()
$obj.CloneProblem()

InvalidOperation：行 | 6 | 返回 $this.MemberwiseClone() # 失败，显示“不包含…| ~~~~~~~~~~~~~~~~~~~~~~~ | 方法调用失败，因为 [MyClass] 不包含名为“MemberwiseClone”的方法。

考虑到相关类可能具有多个派生类，这意味着我不希望在相关方法中对​​类类型进行硬编码，那么创建 PowerShell浅层复制方法替代方案最简洁和/或最高效的解决方法是什么。MyClass1 : MyClass { }

powershell

2 个回答

  1. Best Answer

    最快的方法是创建新对象并对所有现有成员进行硬编码。

    class MyClass {
    [string] $Name

    [object] CloneProblem() {
        return [MyClass]@{ Name = $this.Name }
    }
}

    如果类型有许多成员，最简洁但性能较差的方法是枚举访问PSObject成员的属性。

    class MyClass {
    [string] $Name

    [object] CloneProblem() {
        $clone = [ordered]@{}
        foreach ($property in $this.PSObject.Properties) {
            $clone[$property.Name] = $property.Value
        }

        return [MyClass] $clone
    }
}

    或者，如果您不想在return语句中对类型进行硬编码，则可以使用LanguagePrimitives.ConvertTo：

    return [System.Management.Automation.LanguagePrimitives]::ConvertTo(
            $clone, $this.GetType())

    另一种性能较差的方法是MemberwiseClone通过反射调用，理想情况下MethodInfo应该将其缓存在static字段中。

    class MyClass {
    [string] $Name
    hidden static [System.Reflection.MethodInfo] $s_method

    [object] CloneProblem() {
        if (-not $this::s_method) {
            $this::s_method = [object].GetMethod(
                'MemberwiseClone',
                [System.Reflection.BindingFlags] 'NonPublic, Instance')
        }

        return $this::s_method.Invoke($this, $null)
    }
}

    对以前的方法的后续处理，可能有点过度，因为以前的方法在每种可能的情况下都应该足够了，可以将Func<>代表存储在每个派生的静态字典中。

    using namespace System.Collections.Generic
using namespace System.Linq.Expressions
using namespace System.Reflection

class BaseClass {
    [int] $Age
    hidden static [Dictionary[type, Delegate]] $s_cloneDelegates

    [object] CloneProblem() {
        if (-not $this::s_cloneDelegates) {
            $this::s_cloneDelegates = [Dictionary[type, Delegate]]::new()
        }

        $type = $this.GetType()
        if (-not $this::s_cloneDelegates.ContainsKey($type)) {
            $this::s_cloneDelegates[$type] = [Delegate]::CreateDelegate(
                [Expression]::GetFuncType($type, [object]),
                [object].GetMethod(
                    'MemberwiseClone',
                    [BindingFlags] 'NonPublic, Instance'))
        }

        return $this::s_cloneDelegates[$type].Invoke($this)
    }
}

class MyClass : BaseClass {
    [string] $Name
}

$base = [BaseClass]::new()
$base.CloneProblem().GetType()    # BaseClass
$derived = [MyClass]::new()
$derived.CloneProblem().GetType() # MyClass
    • 2

  2. 为了补充圣地亚哥的有用答案，其中展示了几种有用的技巧：

    最简洁和/或最有效的解决方法是什么？

    最简洁但性能不佳的解决方案是在每次调用时使用反射：

    class MyClass {
  [string]$Name

  [object] CloneProblem() {
    return [object].GetMethod(
             'MemberwiseClone', 
             [System.Reflection.BindingFlags] 'NonPublic, Instance'
           ).Invoke($this, @())
  }
}

# Sample call:
$obj = [MyClass]::new(); $obj.Name = 'foo'
$obj.CloneProblem()

    正如圣地亚哥的回答所指出的，为了获得高性能解决方案，您需要缓存通过反射获得的方法定义，以避免反射带来的性能损失。

    为此，您可以利用这样的事实：可以直接在表示当前类实例的自动变量上使用静态::成员访问运算符。$this

    这不仅比以类型文字 () 的形式重复类名更方便[MyClass]，而且还避免了对返回类型进行硬编码的问题，这会妨碍对类进行子类化（派生）。

    class MyClass {
  [string]$Name
  # Static member variable in which to later cache the MemberwiseCone() method
  # information.
  hidden static [System.Reflection.MethodInfo] $s_cachedMethod

  [object] CloneProblem() {
    # On first call, perform reflection to get the method and also cache
    # it for later use.
    if (-not $this::s_cachedMethod) {
      $this::s_cachedMethod = [object].GetMethod('MemberwiseClone', [System.Reflection.BindingFlags] 'NonPublic, Instance')
    }
    # Invoke the cached method:
    return $this::s_cachedMethod.Invoke($this, @())
  }
  
}

# Sample call via a subclass (derived class):
class MyClassToo : MyClass {}  # sample subclass
# -> $true, proving that .CloneProblem() correctly returns an instance
# of the derived class.
[MyClassToo]::new().CloneProblem() -is [MyClassToo]
    • 1

相关问题