Início / coding / Perguntas / 79531052
Accepted
iRon
Asked: 2025-03-24 20:22:25 +0800 CST

Solução alternativa `#24898`: MemberwiseClone está ausente após atualização para o PowerShell 7.5.0

  • 772

Eu me deparei com este problema: #24898: MemberwiseClone está faltando após a atualização para o PowerShell 7.5.0 :

class MyClass {
     [string]$Name

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

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

InvalidOperation: Linha | 6 | return $this.MemberwiseClone() # Falha com "não contém … | ~~~~~~~~~~~~~~~~~~~~~~~ | A invocação do método falhou porque [MyClass] não contém um método chamado 'MemberwiseClone'.

Qual seria a solução alternativa mais concisa e/ou eficiente para criar uma alternativa ao método de cópia superficial do PowerShell , levando em consideração que a classe em questão pode ter vários derivados, MyClass1 : MyClass { }o que significa que não quero o tipo de classe codificado no método em questão?

powershell

2 respostas

  1. Best Answer

    O mais rápido é criar o novo objeto codificando todos os membros existentes.

    class MyClass {
    [string] $Name

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

    A maneira mais concisa, mas menos eficiente, se o tipo tiver muitos membros, é enumerar as propriedades que acessam PSObjecto membro.

    class MyClass {
    [string] $Name

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

        return [MyClass] $clone
    }
}

    Alternativamente, se você não quiser codificar o tipo na returndeclaração, você pode usar LanguagePrimitives.ConvertTo:

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

    Outro método menos eficiente é invocar MemberwiseClonevia reflexão, idealmente MethodInfodeve ser armazenado em cache em um staticcampo.

    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)
    }
}

    Uma continuação da abordagem anterior, provavelmente exagerada, já que a abordagem anterior deveria ser suficiente em todos os casos possíveis, pode ser armazenar Func<>delegados em um dicionário estático para cada derivado.

    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. Para complementar a resposta útil de Santiago , que mostra diversas técnicas úteis:

    Qual seria a solução alternativa mais concisa e/ou eficiente?

    A solução mais concisa - mas não tão eficiente - é usar reflexão em cada invocação :

    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()

    Como observa a resposta de Santiago, para uma solução de alto desempenho , você precisa armazenar em cache a definição do método obtida por meio de reflexão para evitar o impacto no desempenho que a reflexão acarreta.

    Para fazer isso, você pode aproveitar o fato de poder usar ::, o operador de acesso a membros estáticos , diretamente na variável automática$this que representa a instância de classe em questão.

    Isso não é apenas mais conveniente do que ter que repetir o nome da classe na forma de um literal de tipo ( [MyClass]), mas também evita o problema de codificar o tipo de retorno, o que atrapalharia a subclassificação (derivação) da sua classe.

    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

relate perguntas