Sdílet prostřednictvím

o_třídách_metody

Krátký popis

Popisuje, jak definovat metody pro třídy PowerShellu.

Dlouhý popis

Metody definují akce, které může třída provádět. Metody mohou přijímat parametry, které určují vstupní data. Metody vždy definují výstupní typ. Pokud metoda nevrací žádný výstup, musí mít Void výstupní typ. Pokud metoda explicitně nedefinuje výstupní typ, výstupní typ metody je Void.

V metodách třídy se do kanálu neposílají žádné objekty s výjimkou objektů zadaných v příkazu return. Z kódu neexistuje žádný náhodný výstup kanálu.

Poznámka

To se v podstatě liší od toho, jak funkce PowerShellu zpracovávají výstup, kde všechno směřuje do kanálu.

Neprocházející chyby zapsané do datového proudu chyb uvnitř metody třídy se nepřecházejí. K zobrazení ukončovací chyby musíte použít throw. Pomocí rutin Write-* můžete dál zapisovat do výstupních datových proudů PowerShellu z metody třídy. Rutiny respektují proměnné předvoleb v oboru volání. Měli byste se však vyhnout použití rutin Write-*, aby metoda výstupem pouze objekty pomocí příkazu return.

Metody třídy mohou odkazovat na aktuální instanci objektu třídy pomocí $this automatické proměnné pro přístup k vlastnostem a dalším metodám definovaným v aktuální třídě. Automatická proměnná $this není ve statických metodách dostupná.

Metody tříd mohou mít libovolný počet atributů, včetně skrytých a statických atributů.

Syntaxe

Metody tříd používají následující syntaxe:

Jednořádková syntaxe

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

Víceřádkové syntaxe

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

Examples

Příklad 1 – minimální definice metody

Metoda GetVolume() třídy ExampleCube1 vrátí svazek datové krychle. Definuje výstupní typ jako plovoucí číslo a vrátí výsledek vynásobení Height, Lengtha Width vlastnosti instance.

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

Příklad 2 – metoda s parametry

Metoda GeWeight() vezme pro hustotu datové krychle vstup s plovoucí desetinnou čárkou a vrátí váhu datové krychle vypočítané jako objem vynásobený hustotou.

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

Příklad 3 – metoda bez výstupu

Tento příklad definuje Validate() metodu s výstupním typem jako System.Void. Tato metoda nevrací žádný výstup. Místo toho, pokud se ověření nezdaří, vyvolá chybu. Metoda GetVolume() volá Validate() před výpočtem objemu datové krychle. Pokud ověření selže, metoda se ukončí před výpočtem.

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.

Metoda vyvolá výjimku, protože vlastnosti Height a Width jsou neplatné, což brání třídě v výpočtu aktuálního svazku.

Příklad 4 – Statická metoda s přetíženími

Třída ExampleCube4 definuje statickou metodu GetVolume() se dvěma přetíženími. První přetížení má parametry pro dimenze datové krychle a příznak označující, zda metoda má ověřit vstup.

Druhé přetížení zahrnuje pouze číselné vstupy. Volá první přetížení s $Strict jako $true. Druhé přetížení poskytuje uživatelům způsob, jak volat metodu, aniž by vždy museli definovat, zda má být vstup přísně ověřen.

Třída také definuje GetVolume() jako instance (nonstatic). Tato metoda volá druhé statické přetížení a zajišťuje, že instance GetVolume() metoda vždy ověří dimenze datové krychle před vrácením výstupní hodnoty.

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.

Podrobné zprávy v definicích metody ukazují, jak počáteční volání $this.GetVolume() volá statickou metodu.

Volání statické metody přímo s parametrem Strict jako $false vrátí 0 svazku.

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

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

Podpisy a přetížení metody

Každá metoda třídy má jedinečný podpis, který definuje, jak metodu volat. Výstupní typ, název a parametry metody definují podpis metody.

Když třída definuje více než jednu metodu se stejným názvem, definice této metody jsou přetížení. Přetížení metody musí mít různé parametry. Metoda nemůže definovat dvě implementace se stejnými parametry, i když jsou typy výstupu odlišné.

Následující třída definuje dvě metody, Shuffle() a Deal(). Metoda Deal() definuje dvě přetížení, jedno bez parametrů a druhý s parametrem Count.

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

Výstup metody

Ve výchozím nastavení metody nemají žádný výstup. Pokud podpis metody obsahuje explicitní výstupní typ jiný než Void, metoda musí vrátit objekt tohoto typu. Metody nevygenerují žádný výstup s výjimkou případů, kdy klíčové slovo return explicitně vrací objekt.

Parametry metody

Metody třídy mohou definovat vstupní parametry, které se mají použít v těle metody. Parametry metody jsou uzavřeny v závorkách a jsou odděleny čárkami. Prázdné závorky označují, že metoda nevyžaduje žádné parametry.

Parametry lze definovat na jednom řádku nebo více řádcích. Následující bloky zobrazují syntaxi parametrů metody.

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

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

Parametry metody mohou být silného typu. Pokud parametr není zadán, metoda přijme pro tento parametr jakýkoli objekt. Pokud je parametr zadán, metoda se pokusí převést hodnotu pro tento parametr na správný typ, vyvolá výjimku, pokud vstup nelze převést.

Parametry metody nemůžou definovat výchozí hodnoty. Všechny parametry metody jsou povinné.

Parametry metody nemohou mít žádné další atributy. To brání metodám v používání parametrů s atributy Validate*. Další informace o ověřovacích atributech najdete v tématu about_Functions_Advanced_Parameters.

K přidání ověřování k parametrům metody můžete použít jeden z následujících vzorů:

  1. Znovu přiřaďte parametry ke stejným proměnným s požadovanými ověřovacími atributy. To funguje pro statické i instance metody. Příklad tohoto vzoru najdete v Příklad 4.
  2. Pomocí Update-TypeData definujte ScriptMethod, která přímo používá ověřovací atributy parametrů. To funguje jenom pro metody instancí. Další informace najdete v části Definování metod instance pomocí Update-TypeData.

Automatické proměnné v metodách

Ne všechny automatické proměnné jsou dostupné v metodách. Následující seznam obsahuje automatické proměnné a návrhy, zda a jak je používat v metodách třídy PowerShellu. Automatické proměnné, které nejsou zahrnuté v seznamu, nejsou dostupné pro metody tříd.

  • $? – Access je normální.
  • $_ – Access je normální.
  • $args – místo toho použijte explicitní proměnné parametrů.
  • $ConsoleFileName – Access je místo toho $Script:ConsoleFileName.
  • $Error – Access je normální.
  • $EnabledExperimentalFeatures – Access je místo toho $Script:EnabledExperimentalFeatures.
  • $Event – Access je normální.
  • $EventArgs – Access je normální.
  • $EventSubscriber – Access je normální.
  • $ExecutionContext – Access je místo toho $Script:ExecutionContext.
  • $false – Access je normální.
  • $foreach – Access je normální.
  • $HOME – Access je místo toho $Script:HOME.
  • $Host – Access je místo toho $Script:Host.
  • $input – místo toho použijte explicitní proměnné parametrů.
  • $IsCoreCLR – Access je místo toho $Script:IsCoreCLR.
  • $IsLinux – Access je místo toho $Script:IsLinux.
  • $IsMacOS – Access je místo toho $Script:IsMacOS.
  • $IsWindows – Access je místo toho $Script:IsWindows.
  • $LASTEXITCODE – Access je normální.
  • $Matches – Access je normální.
  • $MyInvocation – Access je normální.
  • $NestedPromptLevel – Access je normální.
  • $null – Access je normální.
  • $PID – Access je místo toho $Script:PID.
  • $PROFILE – Access je místo toho $Script:PROFILE.
  • $PSBoundParameters – Tuto proměnnou nepoužívejte. Je určená pro rutiny a funkce. Použití ve třídě může mít neočekávané vedlejší účinky.
  • $PSCmdlet – Tuto proměnnou nepoužívejte. Je určená pro rutiny a funkce. Použití ve třídě může mít neočekávané vedlejší účinky.
  • $PSCommandPath – Access je normální.
  • $PSCulture – Access je místo toho $Script:PSCulture.
  • $PSEdition – Access je místo toho $Script:PSEdition.
  • $PSHOME – Access je místo toho $Script:PSHOME.
  • $PSItem – Access je normální.
  • $PSScriptRoot – Access je normální.
  • $PSSenderInfo – Access je místo toho $Script:PSSenderInfo.
  • $PSUICulture – Access je místo toho $Script:PSUICulture.
  • $PSVersionTable – Access je místo toho $Script:PSVersionTable.
  • $PWD – Access je normální.
  • $Sender – Access je normální.
  • $ShellId – Access je místo toho $Script:ShellId.
  • $StackTrace – Access je normální.
  • $switch – Access je normální.
  • $this – Access je normální. V metodě třídy je $this vždy aktuální instancí třídy. K vlastnostem a metodám třídy můžete přistupovat. Není k dispozici ve statických metodách.
  • $true – Access je normální.

Další informace o automatických proměnných najdete v tématu about_Automatic_Variables.

Skryté metody

Metody třídy můžete skrýt deklarováním pomocí klíčového slova hidden. Skryté metody třídy jsou:

  • Není součástí seznamu členů třídy vrácených rutinou Get-Member. Pokud chcete zobrazit skryté metody s Get-Member, použijte parametr Force.
  • Nezobrazuje se v dokončování tabulátoru nebo IntelliSense, pokud nedojde k dokončení ve třídě, která definuje skrytou metodu.
  • Veřejné členy třídy. Mohou být volána a děděna. Skrytí metody ji neudělá jako soukromou. Skryje metodu, jak je popsáno v předchozích bodech.

Poznámka

Když skryjete jakékoli přetížení pro metodu, tato metoda je odebrána z IntelliSense, výsledky dokončení a výchozí výstup pro Get-Member.

Další informace o klíčovém slově hidden naleznete v tématu about_Hidden.

Statické metody

Metodu můžete definovat jako vlastní třídu místo instancí třídy deklarací metody pomocí klíčového slova static. Statické metody třídy:

  • Jsou vždy k dispozici nezávisle na vytváření instancí třídy.
  • Sdílí se napříč všemi instancemi třídy.
  • Jsou vždy k dispozici.
  • Nelze získat přístup k vlastnostem instance třídy. Mají přístup pouze ke statickým vlastnostem.
  • Živě pro celou relaci.

Metody odvozené třídy

Když třída je odvozena ze základní třídy, dědí metody základní třídy a jejich přetížení. Všechny přetížení metody definované na základní třídě, včetně skrytých metod, jsou k dispozici v odvozené třídě.

Odvozená třída může přepsat přetížení zděděné metody opětovným definováním v definici třídy. Chcete-li přepsat přetížení, musí být typy parametrů stejné jako pro základní třídu. Typ výstupu přetížení se může lišit.

Na rozdíl od konstruktorů nemohou metody použít syntaxi : base(<parameters>) k vyvolání přetížení základní třídy pro metodu. Redefined přetížení odvozené třídy zcela nahrazuje přetížení definované základní třídou.

Následující příklad ukazuje chování statických metod a metod instancí na odvozených třídách.

Základní třída definuje:

  • Statické metody Now() pro vrácení aktuálního času a DaysAgo() pro vrácení data v minulosti.
  • Instance vlastnost TimeStamp a ToString() instance metoda, která vrací řetězcovou reprezentaci této vlastnosti. Tím se zajistí, že při použití instance v řetězci se místo názvu třídy převede na řetězec datetime.
  • Metoda instance SetTimeStamp() se dvěma přetíženími. Při zavolání metody bez parametrů nastaví TimeStamp na aktuální čas. Když je volána metoda s DateTime, nastaví TimeStamp na tuto hodnotu.
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()
    }
}

Další blok definuje třídy odvozené z BaseClass:

  • DerivedClassA dědí z BaseClass bez přepsání.
  • DerivedClassB přepíše statickou metodu DaysAgo() tak, aby vrátila řetězcovou reprezentaci místo objektu DateTime. Přepíše také metodu instance ToString() tak, aby vrátila časové razítko jako ISO8601 řetězec kalendářního data.
  • DerivedClassC přepíše přetížení bez parametrů metody SetTimeStamp() tak, aby nastavení časového razítka bez parametrů nastavil datum na 10 dní před aktuálním datem.
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))
    }
}

Následující blok ukazuje výstup statické Now() metody pro definované třídy. Výstup je stejný pro každou třídu, protože odvozené třídy nepřepíší implementaci základní třídy metody.

"[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

Další blok volá DaysAgo() statickou metodu každé třídy. Liší se pouze výstup DerivedClassB, protože přerodí základní implementaci.

"[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

Následující blok ukazuje řetězcovou prezentaci nové instance pro každou třídu. Reprezentace DerivedClassB se liší, protože přerodí metodu instance 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

Další blok volá metodu instance SetTimeStamp() pro každou instanci a nastaví vlastnost TimeStamp na konkrétní datum. Každá instance má stejné datum, protože žádná z odvozených tříd nepřepíše parametrizované přetížení metody.

[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

Poslední blok volá SetTimeStamp() bez parametrů. Výstup ukazuje, že hodnota DerivedClassC instance je nastavena na 10 dní před ostatními.

"`$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

Definování metod instance pomocí Update-TypeData

Kromě deklarování metod přímo v definici třídy můžete definovat metody pro instance třídy ve statickém konstruktoru pomocí rutiny Update-TypeData.

Tento fragment kódu použijte jako výchozí bod pro vzor. Podle potřeby nahraďte zástupný text v úhlových závorkách.

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

Spropitné

Rutina Add-Member může přidat vlastnosti a metody do třídy v nestatického konstruktoru, ale rutina se spustí při každém zavolání konstruktoru. Použití Update-TypeData ve statickém konstruktoru zajišťuje, aby kód pro přidání členů do třídy byl spuštěn pouze jednou v relaci.

Definování metod s výchozími hodnotami parametrů a ověřovacími atributy

Metody definované přímo v deklaraci třídy nemůžou definovat výchozí hodnoty ani ověřovací atributy parametrů metody. Chcete-li definovat metody třídy s výchozími hodnotami nebo ověřovacími atributy, musí být definovány jako ScriptMethod členy.

V tomto příkladu třída CardDeck definuje Draw() metodu, která používá ověřovací atribut i výchozí hodnotu pro parametr 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.

Poznámka

I když tento model funguje pro ověřovací atributy, všimněte si, že výjimka je zavádějící a odkazuje na nemožnost přidat atribut. Může to být lepší uživatelské prostředí pro explicitní kontrolu hodnoty parametru a vyvolání smysluplné chyby. Uživatelé tak můžou pochopit, proč se jim zobrazuje chyba a co s tím dělat.

Omezení

Metody třídy PowerShellu mají následující omezení:

  • Parametry metody nemůžou používat žádné atributy, včetně ověřovacích atributů.

    Alternativní řešení: Přeřaďte parametry v těle metody pomocí ověřovacího atributu nebo definujte metodu ve statickém konstruktoru pomocí rutiny Update-TypeData.

  • Parametry metody nemůžou definovat výchozí hodnoty. Parametry jsou vždy povinné.

    Alternativní řešení: Definujte metodu ve statickém konstruktoru pomocí rutiny Update-TypeData.

  • Metody jsou vždy veřejné, i když jsou skryté. Mohou být přepsány, když je třída zděděna.

    Alternativní řešení: Žádné.

  • Pokud je jakékoli přetížení metody skryté, je každé přetížení této metody považováno za skryté.

    Alternativní řešení: Žádné.

Viz také

  • Last updated on