Compartilhar via

about_Classes_Methods

Descrição curta

Descreve como definir métodos para classes do PowerShell.

Descrição longa

Os métodos definem as ações que uma classe pode executar. Os métodos podem adotar parâmetros que especificam dados de entrada. Os métodos sempre definem um tipo de saída. Se um método não retornar nenhuma saída, ele deverá ter o tipo de saída Void. Se um método não definir explicitamente um tipo de saída, o tipo de saída do método será Void.

Em métodos de classe, nenhum objeto é enviado para o pipeline, exceto aqueles especificados na instrução return. Não há saída acidental para o pipeline do código.

Nota

Isso é fundamentalmente diferente de como o PowerShell funciona para lidar com a saída, em que tudo vai para o pipeline.

Erros de não geração gravados no fluxo de erros de dentro de um método de classe não são passados. Você deve usar throw para exibir um erro de encerramento. Usando os cmdlets Write-*, você ainda pode gravar nos fluxos de saída do PowerShell de dentro de um método de classe. Os cmdlets respeitam as variáveis de preferência no escopo de chamada. No entanto, você deve evitar usar os cmdlets Write-* para que o método produza apenas objetos usando a instrução return.

Os métodos de classe podem referenciar a instância atual do objeto de classe usando a variável $this automática para acessar propriedades e outros métodos definidos na classe atual. A variável $this automática não está disponível em métodos estáticos.

Os métodos de classe podem ter vários atributos, incluindo os atributos ocultos e estáticos.

Sintaxe

Os métodos de classe usam as seguintes sintaxes:

Sintaxe de uma linha

[[<attribute>]...] [hidden] [static] [<output-type>] <method-name> ([<method-parameters>]) { <body> }

Sintaxe multilinha

[[<attribute>]...]
[hidden]
[static]
[<output-type>] <method-name> ([<method-parameters>]) {
  <body>
}

Exemplos

Exemplo 1 – Definição mínima do método

O método GetVolume() da classe ExampleCube1 retorna o volume do cubo. Ele define o tipo de saída como um número flutuante e retorna o resultado da multiplicação das propriedades de Altura, de Comprimentoe Largura da instância.

class ExampleCube1 {
    [float]   $Height
    [float]   $Length
    [float]   $Width

    [float] GetVolume() { return $this.Height * $this.Length * $this.Width }
}

$box = [ExampleCube1]@{
    Height = 2
    Length = 2
    Width  = 3
}

$box.GetVolume()

12

Exemplo 2 – Método com parâmetros

O método GeWeight() usa uma entrada de número flutuante para a densidade do cubo e retorna o peso do cubo, calculado como volume multiplicado por densidade.

class ExampleCube2 {
    [float]   $Height
    [float]   $Length
    [float]   $Width

    [float] GetVolume() { return $this.Height * $this.Length * $this.Width }
    [float] GetWeight([float]$Density) {
        return $this.GetVolume() * $Density
    }
}

$cube = [ExampleCube2]@{
    Height = 2
    Length = 2
    Width  = 3
}

$cube.GetWeight(2.5)

30

Exemplo 3 – Método sem saída

Este exemplo define o método Validate() com o tipo de saída como System.Void. Esse método não retorna nenhuma saída. Em vez disso, se a validação falhar, ela gerará um erro. O método GetVolume() chama Validate() antes de calcular o volume do cubo. Se a validação falhar, o método será encerrado antes do cálculo.

class ExampleCube3 {
    [float]   $Height
    [float]   $Length
    [float]   $Width

    [float] GetVolume() {
        $this.Validate()

        return $this.Height * $this.Length * $this.Width
    }

    [void] Validate() {
        $InvalidProperties = @()
        foreach ($Property in @('Height', 'Length', 'Width')) {
            if ($this.$Property -le 0) {
                $InvalidProperties += $Property
            }
        }

        if ($InvalidProperties.Count -gt 0) {
            $Message = @(
                'Invalid cube properties'
                "('$($InvalidProperties -join "', '")'):"
                "Cube dimensions must all be positive numbers."
            ) -join ' '
            throw $Message
        }
    }
}

$Cube = [ExampleCube3]@{ Length = 1 ; Width = -1 }
$Cube

$Cube.GetVolume()

Height Length Width
------ ------ -----
  0.00   1.00 -1.00

Exception:
Line |
  20 |              throw $Message
     |              ~~~~~~~~~~~~~~
     | Invalid cube properties ('Height', 'Width'): Cube dimensions must
     | all be positive numbers.

O método gera uma exceção porque as propriedades Height e Width são inválidas, impedindo que a classe calcule o volume atual.

Exemplo 4 – Método estático com sobrecargas

A classe ExampleCube4 define o método estático GetVolume() com duas sobrecargas. A primeira sobrecarga tem parâmetros para as dimensões do cubo e um sinalizador para indicar se o método deve validar a entrada.

A segunda sobrecarga inclui apenas as entradas numéricas. Ele chama a primeira sobrecarga com $Strict como $true. A segunda sobrecarga fornece aos usuários uma maneira de chamar o método sem sempre ter que definir se deseja validar estritamente a entrada.

A classe também define GetVolume() como um método de instância (não estático). Esse método chama a segunda sobrecarga estática, garantindo que a instância GetVolume() método sempre valide as dimensões do cubo antes de retornar o valor de saída.

class ExampleCube4 {
    [float]   $Height
    [float]   $Length
    [float]   $Width

    static [float] GetVolume(
        [float]$Height,
        [float]$Length,
        [float]$Width,
        [boolean]$Strict
    ) {
        $Signature = "[ExampleCube4]::GetVolume({0}, {1}, {2}, {3})"
        $Signature = $Signature -f $Height, $Length, $Width, $Strict
        Write-Verbose "Called $Signature"

        if ($Strict) {
            [ValidateScript({$_ -gt 0 })]$Height = $Height
            [ValidateScript({$_ -gt 0 })]$Length = $Length
            [ValidateScript({$_ -gt 0 })]$Width  = $Width
        }

        return $Height * $Length * $Width
    }

    static [float] GetVolume([float]$Height, [float]$Length, [float]$Width) {
        $Signature = "[ExampleCube4]::GetVolume($Height, $Length, $Width)"
        Write-Verbose "Called $Signature"

        return [ExampleCube4]::GetVolume($Height, $Length, $Width, $true)
    }

    [float] GetVolume() {
        Write-Verbose "Called `$this.GetVolume()"
        return [ExampleCube4]::GetVolume(
            $this.Height,
            $this.Length,
            $this.Width
        )
    }
}

$VerbosePreference = 'Continue'
$Cube = [ExampleCube4]@{ Height = 2 ; Length = 2 }
$Cube.GetVolume()

VERBOSE: Called $this.GetVolume()
VERBOSE: Called [ExampleCube4]::GetVolume(2, 2, 0)
VERBOSE: Called [ExampleCube4]::GetVolume(2, 2, 0, True)

MetadataError:
Line |
  19 |              [ValidateScript({$_ -gt 0 })]$Width  = $Width
     |              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     | The variable cannot be validated because the value 0 is not a valid
     | value for the Width variable.

As mensagens detalhadas nas definições de método mostram como a chamada inicial para $this.GetVolume() chama o método estático.

Chamar o método estático diretamente com o parâmetro Strict como $false retorna 0 para o volume.

[ExampleCube4]::GetVolume($Cube.Height, $Cube.Length, $Cube.Width, $false)

VERBOSE: Called [ExampleCube4]::GetVolume(2, 2, 0, False)
0

Assinaturas e sobrecargas de método

Cada método de classe tem uma assinatura exclusiva que define como chamar o método. O tipo de saída, o nome e os parâmetros do método definem a assinatura do método.

Quando uma classe define mais de um método com o mesmo nome, as definições desse método são sobrecargas. As sobrecargas de um método devem ter parâmetros diferentes. Um método não pode definir duas implementações com os mesmos parâmetros, mesmo que os tipos de saída sejam diferentes.

A classe a seguir define dois métodos, Shuffle() e Deal(). O método Deal() define duas sobrecargas, uma sem parâmetros e outra com o parâmetro contagem de.

class CardDeck {
    [string[]]$Cards  = @()
    hidden [string[]]$Dealt  = @()
    hidden [string[]]$Suits  = @('Clubs', 'Diamonds', 'Hearts', 'Spades')
    hidden [string[]]$Values = 2..10 + @('Jack', 'Queen', 'King', 'Ace')

    CardDeck() {
        foreach($Suit in $this.Suits) {
            foreach($Value in $this.Values) {
                $this.Cards += "$Value of $Suit"
            }
        }
        $this.Shuffle()
    }

    [void] Shuffle() {
        $this.Cards = $this.Cards + $this.Dealt | Where-Object -FilterScript {
             -not [string]::IsNullOrEmpty($_)
        } | Get-Random -Count $this.Cards.Count
    }

    [string] Deal() {
        if ($this.Cards.Count -eq 0) { throw "There are no cards left." }

        $Card        = $this.Cards[0]
        $this.Cards  = $this.Cards[1..$this.Cards.Count]
        $this.Dealt += $Card

        return $Card
    }

    [string[]] Deal([int]$Count) {
        if ($Count -gt $this.Cards.Count) {
            throw "There are only $($this.Cards.Count) cards left."
        } elseif ($Count -lt 1) {
            throw "You must deal at least 1 card."
        }

        return (1..$Count | ForEach-Object { $this.Deal() })
    }
}

Saída do método

Por padrão, os métodos não têm nenhuma saída. Se uma assinatura de método incluir um tipo de saída explícito diferente de Void, o método deverá retornar um objeto desse tipo. Os métodos não emitem nenhuma saída, exceto quando a palavra-chave return retorna explicitamente um objeto.

Parâmetros de método

Os métodos de classe podem definir parâmetros de entrada a serem usados no corpo do método. Os parâmetros de método são colocados entre parênteses e separados por vírgulas. Parênteses vazios indicam que o método não requer parâmetros.

Os parâmetros podem ser definidos em uma única linha ou em várias linhas. Os blocos a seguir mostram a sintaxe para parâmetros de método.

([[<parameter-type>]]$<parameter-name>[, [[<parameter-type>]]$<parameter-name>])

(
    [[<parameter-type>]]$<parameter-name>[,
    [[<parameter-type>]]$<parameter-name>]
)

Parâmetros de método podem ser fortemente tipado. Se um parâmetro não for digitado, o método aceitará qualquer objeto para esse parâmetro. Se o parâmetro for digitado, o método tentará converter o valor desse parâmetro para o tipo correto, lançando uma exceção se a entrada não puder ser convertida.

Parâmetros de método não podem definir valores padrão. Todos os parâmetros de método são obrigatórios.

Os parâmetros de método não podem ter outros atributos. Isso impede que os métodos usem parâmetros com os atributos Validate*. Para obter mais informações sobre os atributos de validação, consulte about_Functions_Advanced_Parameters.

Você pode usar um dos seguintes padrões para adicionar validação aos parâmetros de método:

  1. Reatribua os parâmetros para as mesmas variáveis com os atributos de validação necessários. Isso funciona para métodos estáticos e de instância. Para obter um exemplo desse padrão, consulte Exemplo 4.
  2. Use Update-TypeData para definir um ScriptMethod que usa atributos de validação diretamente nos parâmetros. Isso só funciona para métodos de instância. Para obter mais informações, consulte a seção Definindo métodos de instância com a seção Update-TypeData.

Variáveis automáticas em métodos

Nem todas as variáveis automáticas estão disponíveis em métodos. A lista a seguir inclui variáveis automáticas e sugestões para saber se e como usá-las em métodos de classe do PowerShell. As variáveis automáticas não incluídas na lista não estão disponíveis para métodos de classe.

  • $? - Acessar normalmente.
  • $_ - Acessar normalmente.
  • $args – Use as variáveis de parâmetro explícitas.
  • $ConsoleFileName – Acessar como $Script:ConsoleFileName em vez disso.
  • $Error - Acessar normalmente.
  • $EnabledExperimentalFeatures – Acessar como $Script:EnabledExperimentalFeatures em vez disso.
  • $Event - Acessar normalmente.
  • $EventArgs - Acessar normalmente.
  • $EventSubscriber - Acessar normalmente.
  • $ExecutionContext – Acessar como $Script:ExecutionContext em vez disso.
  • $false - Acessar normalmente.
  • $foreach - Acessar normalmente.
  • $HOME – Acessar como $Script:HOME em vez disso.
  • $Host – Acessar como $Script:Host em vez disso.
  • $input – Use as variáveis de parâmetro explícitas.
  • $IsCoreCLR – Acessar como $Script:IsCoreCLR em vez disso.
  • $IsLinux – Acessar como $Script:IsLinux em vez disso.
  • $IsMacOS – Acessar como $Script:IsMacOS em vez disso.
  • $IsWindows – Acessar como $Script:IsWindows em vez disso.
  • $LASTEXITCODE - Acessar normalmente.
  • $Matches - Acessar normalmente.
  • $MyInvocation - Acessar normalmente.
  • $NestedPromptLevel - Acessar normalmente.
  • $null - Acessar normalmente.
  • $PID – Acessar como $Script:PID em vez disso.
  • $PROFILE – Acessar como $Script:PROFILE em vez disso.
  • $PSBoundParameters - Não use essa variável. Destina-se a cmdlets e funções. Usá-lo em uma classe pode ter efeitos colaterais inesperados.
  • $PSCmdlet - Não use essa variável. Destina-se a cmdlets e funções. Usá-lo em uma classe pode ter efeitos colaterais inesperados.
  • $PSCommandPath - Acessar normalmente.
  • $PSCulture – Acessar como $Script:PSCulture em vez disso.
  • $PSEdition – Acessar como $Script:PSEdition em vez disso.
  • $PSHOME – Acessar como $Script:PSHOME em vez disso.
  • $PSItem - Acessar normalmente.
  • $PSScriptRoot - Acessar normalmente.
  • $PSSenderInfo – Acessar como $Script:PSSenderInfo em vez disso.
  • $PSUICulture – Acessar como $Script:PSUICulture em vez disso.
  • $PSVersionTable – Acessar como $Script:PSVersionTable em vez disso.
  • $PWD - Acessar normalmente.
  • $Sender - Acessar normalmente.
  • $ShellId – Acessar como $Script:ShellId em vez disso.
  • $StackTrace - Acessar normalmente.
  • $switch - Acessar normalmente.
  • $this - Acessar normalmente. Em um método de classe, $this é sempre a instância atual da classe. Você pode acessar as propriedades e os métodos de classe com ela. Ele não está disponível em métodos estáticos.
  • $true - Acessar normalmente.

Para obter mais informações sobre variáveis automáticas, consulte about_Automatic_Variables.

Métodos ocultos

Você pode ocultar métodos de uma classe declarando-os com a palavra-chave hidden. Os métodos de classe ocultos são:

  • Não incluído na lista de membros de classe retornados pelo cmdlet Get-Member. Para mostrar métodos ocultos com Get-Member, use o parâmetro Force.
  • Não exibido na conclusão da guia ou no IntelliSense, a menos que a conclusão ocorra na classe que define o método oculto.
  • Membros públicos da classe. Eles podem ser chamados e herdados. Ocultar um método não o torna privado. Ele oculta apenas o método conforme descrito nos pontos anteriores.

Nota

Quando você oculta qualquer sobrecarga para um método, esse método é removido do IntelliSense, os resultados de conclusão e a saída padrão para Get-Member.

Para obter mais informações sobre a palavra-chave hidden, consulte about_Hidden.

Métodos estáticos

Você pode definir um método como pertencente à própria classe em vez de instâncias da classe declarando o método com a palavra-chave static. Métodos de classe estáticos:

  • Estão sempre disponíveis, independentemente da instanciação de classe.
  • São compartilhados em todas as instâncias da classe.
  • Estão sempre disponíveis.
  • Não é possível acessar as propriedades da instância da classe. Eles só podem acessar propriedades estáticas.
  • Ao vivo durante todo o período de sessão.

Métodos de classe derivada

Quando uma classe deriva de uma classe base, ela herda os métodos da classe base e suas sobrecargas. Todas as sobrecargas de método definidas na classe base, incluindo métodos ocultos, estão disponíveis na classe derivada.

Uma classe derivada pode substituir uma sobrecarga de método herdado redefinindo-a na definição de classe. Para substituir a sobrecarga, os tipos de parâmetro devem ser os mesmos da classe base. O tipo de saída para a sobrecarga pode ser diferente.

Ao contrário dos construtores, os métodos não podem usar a sintaxe : base(<parameters>) para invocar uma sobrecarga de classe base para o método. A sobrecarga redefinida na classe derivada substitui completamente a sobrecarga definida pela classe base.

O exemplo a seguir mostra o comportamento de métodos estáticos e de instância em classes derivadas.

A classe base define:

  • Os métodos estáticos Now() para retornar a hora atual e DaysAgo() para retornar uma data no passado.
  • A propriedade de instância TimeStamp e um método de instância de ToString() que retorna a representação de cadeia de caracteres dessa propriedade. Isso garante que, quando uma instância é usada em uma cadeia de caracteres, ela é convertida na cadeia de caracteres datetime em vez do nome da classe.
  • O método de instância SetTimeStamp() com duas sobrecargas. Quando o método é chamado sem parâmetros, ele define o timeStamp para a hora atual. Quando o método é chamado com um DateTime, ele define o TimeStamp para esse valor.
class BaseClass {
    static [datetime] Now() {
        return Get-Date
    }
    static [datetime] DaysAgo([int]$Count) {
        return [BaseClass]::Now().AddDays(-$Count)
    }

    [datetime] $TimeStamp = [BaseClass]::Now()

    [string] ToString() {
        return $this.TimeStamp.ToString()
    }

    [void] SetTimeStamp([datetime]$TimeStamp) {
        $this.TimeStamp = $TimeStamp
    }
    [void] SetTimeStamp() {
        $this.TimeStamp = [BaseClass]::Now()
    }
}

O próximo bloco define classes derivadas de baseclass:

  • DerivedClassA herda de BaseClass sem substituições.
  • DerivedClassB substitui o método estático DaysAgo() para retornar uma representação de cadeia de caracteres em vez do objeto DateTime. Ele também substitui o método ToString() instância para retornar o carimbo de data/hora como uma cadeia de caracteres de data ISO8601.
  • DerivedClassC substitui a sobrecarga sem parâmetros do método SetTimeStamp() de modo que definir o carimbo de data/hora sem parâmetros define a data como 10 dias antes da data atual.
class DerivedClassA : BaseClass     {}
class DerivedClassB : BaseClass     {
    static [string] DaysAgo([int]$Count) {
        return [BaseClass]::DaysAgo($Count).ToString('yyyy-MM-dd')
    }
    [string] ToString() {
        return $this.TimeStamp.ToString('yyyy-MM-dd')
    }
}
class DerivedClassC : BaseClass {
    [void] SetTimeStamp() {
        $this.SetTimeStamp([BaseClass]::Now().AddDays(-10))
    }
}

O bloco a seguir mostra a saída do método de Now() estático para as classes definidas. A saída é a mesma para cada classe, pois as classes derivadas não substituem a implementação da classe base do método.

"[BaseClass]::Now()     => $([BaseClass]::Now())"
"[DerivedClassA]::Now() => $([DerivedClassA]::Now())"
"[DerivedClassB]::Now() => $([DerivedClassB]::Now())"
"[DerivedClassC]::Now() => $([DerivedClassC]::Now())"

[BaseClass]::Now()     => 11/06/2023 09:41:23
[DerivedClassA]::Now() => 11/06/2023 09:41:23
[DerivedClassB]::Now() => 11/06/2023 09:41:23
[DerivedClassC]::Now() => 11/06/2023 09:41:23

O próximo bloco chama o método estático DaysAgo() de cada classe. Somente a saída para DerivedClassB é diferente, pois ela substituiu a implementação base.

"[BaseClass]::DaysAgo(3)     => $([BaseClass]::DaysAgo(3))"
"[DerivedClassA]::DaysAgo(3) => $([DerivedClassA]::DaysAgo(3))"
"[DerivedClassB]::DaysAgo(3) => $([DerivedClassB]::DaysAgo(3))"
"[DerivedClassC]::DaysAgo(3) => $([DerivedClassC]::DaysAgo(3))"

[BaseClass]::DaysAgo(3)     => 11/03/2023 09:41:38
[DerivedClassA]::DaysAgo(3) => 11/03/2023 09:41:38
[DerivedClassB]::DaysAgo(3) => 2023-11-03
[DerivedClassC]::DaysAgo(3) => 11/03/2023 09:41:38

O bloco a seguir mostra a apresentação de cadeia de caracteres de uma nova instância para cada classe. A representação para DerivedClassB é diferente porque substituiu o método de instância ToString().

"`$base = [BaseClass]::new()     => $($base = [BaseClass]::new(); $base)"
"`$a    = [DerivedClassA]::new() => $($a = [DerivedClassA]::new(); $a)"
"`$b    = [DerivedClassB]::new() => $($b = [DerivedClassB]::new(); $b)"
"`$c    = [DerivedClassC]::new() => $($c = [DerivedClassC]::new(); $c)"

$base = [BaseClass]::new()     => 11/6/2023 9:44:57 AM
$a    = [DerivedClassA]::new() => 11/6/2023 9:44:57 AM
$b    = [DerivedClassB]::new() => 2023-11-06
$c    = [DerivedClassC]::new() => 11/6/2023 9:44:57 AM

O próximo bloco chama o método de instância SetTimeStamp() para cada instância, definindo a propriedade TimeStamp como uma data específica. Cada instância tem a mesma data, pois nenhuma das classes derivadas substitui a sobrecarga parametrizada para o método.

[datetime]$Stamp = '2024-10-31'
"`$base.SetTimeStamp(`$Stamp) => $($base.SetTimeStamp($Stamp) ; $base)"
"`$a.SetTimeStamp(`$Stamp)    => $($a.SetTimeStamp($Stamp); $a)"
"`$b.SetTimeStamp(`$Stamp)    => $($b.SetTimeStamp($Stamp); $b)"
"`$c.SetTimeStamp(`$Stamp)    => $($c.SetTimeStamp($Stamp); $c)"

$base.SetTimeStamp($Stamp) => 10/31/2024 12:00:00 AM
$a.SetTimeStamp($Stamp)    => 10/31/2024 12:00:00 AM
$b.SetTimeStamp($Stamp)    => 2024-10-31
$c.SetTimeStamp($Stamp)    => 10/31/2024 12:00:00 AM

As últimas chamadas de bloco SetTimeStamp() sem parâmetros. A saída mostra que o valor da instância DerivedClassC é definido como 10 dias antes dos outros.

"`$base.SetTimeStamp() => $($base.SetTimeStamp() ; $base)"
"`$a.SetTimeStamp()    => $($a.SetTimeStamp(); $a)"
"`$b.SetTimeStamp()    => $($b.SetTimeStamp(); $b)"
"`$c.SetTimeStamp()    => $($c.SetTimeStamp(); $c)"

$base.SetTimeStamp() => 11/6/2023 9:53:58 AM
$a.SetTimeStamp()    => 11/6/2023 9:53:58 AM
$b.SetTimeStamp()    => 2023-11-06
$c.SetTimeStamp()    => 10/27/2023 9:53:58 AM

Definir métodos de instância com Update-TypeData

Além de declarar métodos diretamente na definição de classe, você pode definir métodos para instâncias de uma classe no construtor estático usando o cmdlet Update-TypeData.

Use esse snippet como ponto de partida para o padrão. Substitua o texto do espaço reservado em colchetes angulares conforme necessário.

class <ClassName> {
    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberName = '<MethodName>'
            MemberType = 'ScriptMethod'
            Value      = {
              param(<method-parameters>)

              <method-body>
            }
        }
    )

    static <ClassName>() {
        $TypeName = [<ClassName>].Name
        foreach ($Definition in [<ClassName>]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }
}

Ponta

O cmdlet Add-Member pode adicionar propriedades e métodos a uma classe em construtores não estáticos, mas o cmdlet é executado sempre que o construtor é chamado. Usar Update-TypeData no construtor estático garante que o código para adicionar os membros à classe só precise ser executado uma vez em uma sessão.

Definindo métodos com valores de parâmetro padrão e atributos de validação

Métodos definidos diretamente em uma declaração de classe não podem definir valores padrão ou atributos de validação nos parâmetros do método. Para definir métodos de classe com valores padrão ou atributos de validação, eles devem ser definidos como membros ScriptMethod.

Neste exemplo, a classe CardDeck define um método Draw() que usa um atributo de validação e um valor padrão para o parâmetro Count.

class CookieJar {
    [int] $Cookies = 12

    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberName = 'Eat'
            MemberType = 'ScriptMethod'
            Value      = {
                param(
                    [ValidateScript({ $_ -ge 1 -and $_ -le $this.Cookies })]
                    [int] $Count = 1
                )

                $this.Cookies -= $Count
                if ($Count -eq 1) {
                    "You ate 1 cookie. There are $($this.Cookies) left."
                } else {
                    "You ate $Count cookies. There are $($this.Cookies) left."
                }
            }
        }
    )

    static CookieJar() {
        $TypeName = [CookieJar].Name
        foreach ($Definition in [CookieJar]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }
}

$Jar = [CookieJar]::new()
$Jar.Eat(1)
$Jar.Eat()
$Jar.Eat(20)
$Jar.Eat(6)

You ate 1 cookie. There are 11 left.

You ate 1 cookie. There are 10 left.

MethodInvocationException:
Line |
  36 |  $Jar.Eat(20)
     |  ~~~~~~~~~~~~
     | Exception calling "Eat" with "1" argument(s): "The attribute
     | cannot be added because variable Count with value 20 would no
     | longer be valid."

You ate 6 cookies. There are 4 left.

Nota

Embora esse padrão funcione para atributos de validação, observe que a exceção é enganosa, fazendo referência a uma incapacidade de adicionar um atributo. Pode ser uma melhor experiência do usuário verificar explicitamente o valor do parâmetro e gerar um erro significativo. Dessa forma, os usuários podem entender por que estão vendo o erro e o que fazer a respeito.

Limitações

Os métodos de classe do PowerShell têm as seguintes limitações:

  • Os parâmetros de método não podem usar nenhum atributo, incluindo atributos de validação.

    Solução alternativa: reatribua os parâmetros no corpo do método com o atributo de validação ou defina o método no construtor estático com o cmdlet Update-TypeData.

  • Parâmetros de método não podem definir valores padrão. Os parâmetros são sempre obrigatórios.

    Solução alternativa: defina o método no construtor estático com o cmdlet Update-TypeData.

  • Os métodos são sempre públicos, mesmo quando estão ocultos. Eles podem ser substituídos quando a classe é herdada.

    Solução alternativa: nenhuma.

  • Se qualquer sobrecarga de um método estiver oculta, cada sobrecarga desse método também será tratada como oculta.

    Solução alternativa: nenhuma.

Consulte também

  • Last updated on