about_Classes_Methods

Makale
11/14/2023

Kısa açıklama

PowerShell sınıfları için yöntemlerin nasıl tanımlanacağı açıklanır.

Uzun açıklama

Yöntemler, bir sınıfın gerçekleştirebildiği eylemleri tanımlar. Yöntemler, giriş verilerini belirten parametreleri alabilir. Yöntemler her zaman bir çıkış türü tanımlar. Bir yöntem herhangi bir çıkış döndürmezse Void çıkış türüne sahip olmalıdır. Bir yöntem açıkça bir çıkış türü tanımlamazsa, yöntemin çıkış türü Void olur.

Sınıf yöntemlerinde, deyiminde belirtilenler dışında işlem hattına hiçbir nesne gönderilmez return . koddan işlem hattına yanlışlıkla çıkış yapılmaz.

Not

Bu, PowerShell işlevlerinin çıkışı işleme yönteminden temel olarak farklıdır ve her şey işlem hattına gider.

Sınıf yönteminin içinden hata akışına yazılan sonlandırılmayan hatalar geçirilmiyor. Sonlandırıcı bir hatayı ortaya çıkarabilmek için komutunu kullanmanız throw gerekir. Cmdlet'leri Write-* kullanarak, bir sınıf yöntemi içinden PowerShell'in çıkış akışlarına yazmaya devam edebilirsiniz. Cmdlet'ler, arama kapsamındaki tercih değişkenlerini dikkate alır . Ancak, yöntemin yalnızca deyimini Write-* kullanarak return nesne çıkışı yapması için cmdlet'lerini kullanmaktan kaçınmanız gerekir.

Sınıf yöntemleri, geçerli sınıfta tanımlanan özelliklere ve diğer yöntemlere erişmek için otomatik değişkeni kullanarak $this sınıf nesnesinin geçerli örneğine başvurabilir. Otomatik $this değişken statik yöntemlerde kullanılamaz.

Sınıf yöntemlerinde gizli ve statik öznitelikler de dahil olmak üzere herhangi bir sayıda öznitelik bulunabilir.

Sözdizimi

Sınıf yöntemleri aşağıdaki söz dizimlerini kullanır:

Tek satırlık söz dizimi

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

Çok satırlı söz dizimi

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

Örnekler

Örnek 1 - En az yöntem tanımı

GetVolume() ExampleCube1 sınıfının yöntemi küp hacmini döndürür. Çıkış türünü kayan bir sayı olarak tanımlar ve örneğin Yükseklik, Uzunluk ve Genişlik özelliklerinin çarpımının sonucunu döndürür.

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

Örnek 2 - Parametreleri olan yöntem

yöntemi, GeWeight() küp yoğunluğu için kayan bir sayı girişi alır ve yoğunlukla çarpılan hacim olarak hesaplanan küp ağırlığını döndürür.

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)

Örnek 3 - Çıkışsız yöntem

Bu örnek, çıkış türü System.Void olan yöntemini tanımlarValidate(). Bu yöntem çıkış döndürmez. Bunun yerine, doğrulama başarısız olursa bir hata oluşturur. yöntemi, GetVolume() küp hacmini hesaplamadan önce çağırır Validate() . Doğrulama başarısız olursa, yöntem hesaplamadan önce sonlanır.

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.

Height ve Width özellikleri geçersiz olduğundan yöntemi bir özel durum oluşturur ve sınıfın geçerli birimi hesaplamasını engeller.

Örnek 4 - Aşırı yüklemelerle statik yöntem

ExampleCube4 sınıfı, statik yöntemi GetVolume() iki aşırı yüklemeyle tanımlar. İlk aşırı yüklemede küp boyutları için parametreler ve yöntemin girişi doğrulayıp doğrulamayacağını belirten bir bayrak bulunur.

İkinci aşırı yükleme yalnızca sayısal girişleri içerir. ile $Static ilk aşırı yüklemeyi olarak $trueçağırır. İkinci aşırı yükleme, kullanıcılara her zaman girişi kesin olarak doğrulayıp doğrulamayacağını tanımlamak zorunda kalmadan yöntemini çağırmak için bir yol sağlar.

sınıfı da bir örnek (statik olmayan) yöntemi olarak tanımlar GetVolume() . Bu yöntem ikinci statik aşırı yüklemeyi çağırarak örnek GetVolume() yönteminin çıkış değerini döndürmeden önce küp boyutlarını her zaman doğrulamasını sağlar.

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.

Yöntem tanımlarındaki ayrıntılı iletiler, statik yöntemi çağırmak için $this.GetVolume() yapılan ilk çağrıyı gösterir.

Statik yöntemi doğrudan Strict parametresiyle $false çağırmak birim için döndürür0.

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

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

Yöntem imzaları ve aşırı yüklemeleri

Her sınıf yöntemi, yönteminin nasıl çağrıldığını tanımlayan benzersiz bir imzaya sahiptir. Yöntemin çıkış türü, adı ve parametreleri yöntem imzasını tanımlar.

Bir sınıf aynı ada sahip birden fazla yöntem tanımladığında, bu yöntemin tanımları aşırı yüklemelerdir. Bir yöntem için aşırı yüklemelerin farklı parametreleri olmalıdır. Bir yöntem, çıkış türleri farklı olsa bile aynı parametrelere sahip iki uygulama tanımlayamaz.

Aşağıdaki sınıf ve Deal()adlı iki yöntemi Shuffle() tanımlar. Deal() yöntemi, biri parametresiz, diğeri count parametresiyle iki aşırı yükleme tanımlar.

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

Yöntem çıkışı

Varsayılan olarak, yöntemlerin çıkışı yoktur. Yöntem imzası Void dışında açık bir çıkış türü içeriyorsa, yöntemin bu türde bir nesne döndürmesi gerekir. Anahtar sözcüğü açıkça bir nesne döndürdüğü durumlar return dışında yöntemler herhangi bir çıkış yaymaz.

Yöntem parametreleri

Sınıf yöntemleri, yöntem gövdesinde kullanılacak giriş parametrelerini tanımlayabilir. Yöntem parametreleri parantez içine alınır ve virgülle ayrılır. Boş ayraçlar yöntemin parametre gerektirmediğini gösterir.

Parametreler tek bir satırda veya birden çok satırda tanımlanabilir. Aşağıdaki bloklar, yöntem parametrelerinin söz dizimini gösterir.

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

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

Yöntem parametreleri kesin olarak yazılabilir. Bir parametre yazılmıyorsa, yöntemi bu parametre için herhangi bir nesneyi kabul eder. Parametresi girilirse, yöntemi bu parametrenin değerini doğru türe dönüştürmeyi dener ve giriş dönüştürülemezse bir özel durum oluşturur.

Yöntem parametreleri varsayılan değerleri tanımlayamaz. Tüm yöntem parametreleri zorunlu.

Yöntem parametrelerinin başka öznitelikleri olamaz. Bu, yöntemlerin özniteliklerle Validate* parametreleri kullanmasını engeller. Doğrulama öznitelikleri hakkında daha fazla bilgi için bkz . about_Functions_Advanced_Parameters.

Yöntem parametrelerine doğrulama eklemek için aşağıdaki desenlerden birini kullanabilirsiniz:

Gerekli doğrulama öznitelikleriyle parametreleri aynı değişkenlere yeniden atayın. Bu hem statik hem de örnek yöntemleri için çalışır. Bu desenin bir örneği için bkz . Örnek 4.
Doğrudan parametrelerde doğrulama özniteliklerini kullanan bir ScriptMethod tanımlamak için kullanınUpdate-TypeData. Bu yalnızca örnek yöntemleri için çalışır. Daha fazla bilgi için Update-TypeData ile örnek yöntemlerini tanımlama bölümüne bakın.

Yöntemlerdeki otomatik değişkenler

Tüm otomatik değişkenler yöntemlerde kullanılamaz. Aşağıdaki listede otomatik değişkenler ve bunların PowerShell sınıf yöntemlerinde kullanılıp kullanılmaymayacağı ve nasıl kullanılacağına yönelik öneriler yer alır. Listeye dahil olmayan otomatik değişkenler sınıf yöntemleri tarafından kullanılamaz.

$? - Normal erişim.
$_ - Normal erişim.
$args - Bunun yerine açık parametre değişkenlerini kullanın.
$ConsoleFileName - Bunun yerine erişim $Script:ConsoleFileName .
$Error - Normal erişim.
$EnabledExperimentalFeatures - Bunun yerine erişim $Script:EnabledExperimentalFeatures .
$Event - Normal erişim.
$EventArgs - Normal erişim.
$EventSubscriber - Normal erişim.
$ExecutionContext - Bunun yerine erişim $Script:ExecutionContext .
$false - Normal erişim.
$foreach - Normal erişim.
$HOME - Bunun yerine erişim $Script:HOME .
$Host - Bunun yerine erişim $Script:Host .
$input - Bunun yerine açık parametre değişkenlerini kullanın.
$IsCoreCLR - Bunun yerine erişim $Script:IsCoreCLR .
$IsLinux - Bunun yerine erişim $Script:IsLinux .
$IsMacOS - Bunun yerine erişim $Script:IsMacOS .
$IsWindows - Bunun yerine erişim $Script:IsWindows .
$LASTEXITCODE - Normal erişim.
$Matches - Normal erişim.
$MyInvocation - Normal erişim.
$NestedPromptLevel - Normal erişim.
$null - Normal erişim.
$PID - Bunun yerine erişim $Script:PID .
$PROFILE - Bunun yerine erişim $Script:PROFILE .
$PSBoundParameters - Bu değişkeni kullanmayın. Cmdlet'ler ve işlevler için tasarlanmıştır. Bunu bir sınıfta kullanmak beklenmeyen yan etkilere neden olabilir.
$PSCmdlet - Bu değişkeni kullanmayın. Cmdlet'ler ve işlevler için tasarlanmıştır. Bunu bir sınıfta kullanmak beklenmeyen yan etkilere neden olabilir.
$PSCommandPath - Normal erişim.
$PSCulture - Bunun yerine erişim $Script:PSCulture .
$PSEdition - Bunun yerine erişim $Script:PSEdition .
$PSHOME - Bunun yerine erişim $Script:PSHOME .
$PSItem - Normal erişim.
$PSScriptRoot - Normal erişim.
$PSSenderInfo - Bunun yerine erişim $Script:PSSenderInfo .
$PSUICulture - Bunun yerine erişim $Script:PSUICulture .
$PSVersionTable - Bunun yerine erişim $Script:PSVersionTable .
$PWD - Normal erişim.
$Sender - Normal erişim.
$ShellId - Bunun yerine erişim $Script:ShellId .
$StackTrace - Normal erişim.
$switch - Normal erişim.
$this - Normal erişim. Bir sınıf yönteminde, $this her zaman sınıfının geçerli örneğidir. Sınıf özelliklerine ve yöntemlerine onunla erişebilirsiniz. Statik yöntemlerde kullanılamaz.
$true - Normal erişim.

Otomatik değişkenler hakkında daha fazla bilgi için bkz . about_Automatic_Variables.

Gizli yöntemler

Bir sınıfın yöntemlerini anahtar sözcüğüyle hidden bildirerek gizleyebilirsiniz. Gizli sınıf yöntemleri şunlardır:

cmdlet'i tarafından Get-Member döndürülen sınıf üyeleri listesine dahil değildir. ile Get-Membergizli yöntemleri göstermek için Force parametresini kullanın.
Gizli yöntemi tanımlayan sınıfta tamamlanma gerçekleşmediği sürece sekme tamamlama veya IntelliSense'te görüntülenmez.
Sınıfın genel üyeleri. Bunlar çağrılabilir ve devralınabilir. Bir yöntemin gizlenmesi onu özel yapmaz. Yalnızca önceki noktalarda açıklandığı gibi yöntemini gizler.

Not

Bir yöntemin aşırı yüklemesini gizlediğinizde, bu yöntem IntelliSense'ten, tamamlanma sonuçlarından ve için Get-Membervarsayılan çıktıdan kaldırılır.

Anahtar sözcük hakkında hidden daha fazla bilgi için bkz . about_Hidden.

Statik yöntemler

yöntemini anahtar sözcüğüyle static bildirerek sınıfın örnekleri yerine sınıfın kendisine ait olarak tanımlayabilirsiniz. Statik sınıf yöntemleri:

Sınıf örneklemeden bağımsız olarak her zaman kullanılabilir.
Sınıfın tüm örnekleri arasında paylaşılır.
Her zaman kullanılabilir.
Sınıfının örnek özelliklerine erişemiyorum. Yalnızca statik özelliklere erişebilirler.
Tüm oturum süresi boyunca canlı.

Türetilmiş sınıf yöntemleri

Bir sınıf bir temel sınıftan türetildiğinde, temel sınıfın yöntemlerini ve bunların aşırı yüklemelerini devralır. Gizli yöntemler de dahil olmak üzere temel sınıfta tanımlanan tüm yöntem aşırı yüklemeleri türetilmiş sınıfta kullanılabilir.

Türetilmiş bir sınıf, devralınan yöntem aşırı yüklemesini sınıf tanımında yeniden tanımlayarak geçersiz kılabilir. Aşırı yüklemeyi geçersiz kılmak için parametre türlerinin temel sınıfla aynı olması gerekir. Aşırı yüklemenin çıkış türü farklı olabilir.

Oluşturuculardan farklı olarak yöntemler, yöntemi için : base(<parameters>) temel sınıf aşırı yüklemesini çağırmak için söz dizimini kullanamaz. Türetilmiş sınıftaki yeniden tanımlanan aşırı yükleme, temel sınıf tarafından tanımlanan aşırı yüklemenin yerini tamamen alır.

Aşağıdaki örnekte türetilmiş sınıflarda statik ve örnek yöntemlerine yönelik davranış gösterilmektedir.

Temel sınıf aşağıdakileri tanımlar:

Geçerli saati döndürmek ve DaysAgo() geçmişteki bir tarihi döndürmek için statik yöntemlerNow().
TimeStamp örnek özelliği ve bu özelliğin dize gösterimini döndüren bir ToString() örnek yöntemi. Bu, bir dizede örnek kullanıldığında sınıf adı yerine datetime dizesine dönüştürülmesini sağlar.
İki aşırı yükleme içeren örnek yöntemi SetTimeStamp() . yöntemi parametresiz çağrıldığında TimeStamp'ı geçerli saate ayarlar. Yöntemi bir DateTime ile çağrıldığında TimeStamp değerini bu değere ayarlar.

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

Sonraki blok BaseClass'tan türetilen sınıfları tanımlar:

DerivedClassA, BaseClass'tanherhangi bir geçersiz kılma olmadan devralır.
DerivedClassB, DateTime nesnesi yerine dize gösterimi döndürmek için statik yöntemi geçersiz kılarDaysAgo(). Ayrıca, zaman damgasını ToString() bir ISO8601 tarih dizesi olarak döndürmek için örnek yöntemini geçersiz kılar.
DerivedClassC , yöntemin parametresiz aşırı yüklemesini SetTimeStamp() geçersiz kılar, böylece zaman damgasını parametreler olmadan ayarlamak tarihi geçerli tarihten 10 gün öncesine ayarlar.

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

Aşağıdaki blok, tanımlı sınıflar için statik Now() yöntemin çıkışını gösterir. Türetilmiş sınıflar yöntemin temel sınıf uygulamasını geçersiz kılmadığından çıkış her sınıf için aynıdır.

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

Sonraki blok her sınıfın DaysAgo() statik yöntemini çağırır. Yalnızca DerivedClassB çıktısı farklıdır çünkü temel uygulama geçersizdir.

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

Aşağıdaki blok, her sınıf için yeni bir örneğin dize sunumunu gösterir. DerivedClassB gösterimi, örnek yöntemini aştığı ToString() için farklıdır.

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

Sonraki blok her örnek için örnek yöntemini çağırır SetTimeStamp() ve TimeStamp özelliğini belirli bir tarihe ayarlar. Türetilmiş sınıfların hiçbiri yöntemi için parametreli aşırı yüklemeyi geçersiz kılmadığından her örnek aynı tarihe sahiptir.

[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

Son blok parametresiz çağrılar SetTimeStamp() . Çıkış, DerivedClassC örneğinin değerinin diğerlerinden 10 gün önce olarak ayarlandığını gösterir.

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

Update-TypeData ile örnek yöntemlerini tanımlama

Yöntemleri doğrudan sınıf tanımında bildirmenin ötesinde, cmdlet'ini kullanarak statik oluşturucuda bir sınıfın Update-TypeData örnekleri için yöntemler tanımlayabilirsiniz.

Bu kod parçacığını desen için başlangıç noktası olarak kullanın. Köşeli ayraç içindeki yer tutucu metni gerektiği gibi değiştirin.

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

İpucu

Add-Member Cmdlet, statik olmayan oluşturuculardaki bir sınıfa özellik ve yöntemler ekleyebilir, ancak oluşturucu her çağrıldığında cmdlet çalışır. Update-TypeData Statik oluşturucuda kullanmak, sınıfa üye ekleme kodunun oturumda yalnızca bir kez çalıştırılmasını sağlar.

Varsayılan parametre değerleri ve doğrulama öznitelikleriyle yöntemleri tanımlama

Doğrudan bir sınıf bildiriminde tanımlanan yöntemler, yöntem parametrelerinde varsayılan değerleri veya doğrulama özniteliklerini tanımlayamaz. Varsayılan değerlere veya doğrulama özniteliklerine sahip sınıf yöntemlerini tanımlamak için ScriptMethod üyeleri olarak tanımlanmalıdır.

Bu örnekte CardDeck sınıfı, Count parametresi için hem doğrulama özniteliği hem de varsayılan değer kullanan bir yöntem tanımlarDraw().

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.

Not

Bu desen doğrulama öznitelikleri için işe yarasa da, özel durumun yanıltıcı olduğuna ve öznitelik eklenememesine başvurduğunuza dikkat edin. Parametresinin değerini açıkça denetlemek ve bunun yerine anlamlı bir hata oluşturmak daha iyi bir kullanıcı deneyimi olabilir. Bu şekilde kullanıcılar hatayı neden gördüklerini ve bu konuda ne yapacaklarını anlayabilir.

Sınırlamalar

PowerShell sınıf yöntemleri aşağıdaki sınırlamalara sahiptir:

Yöntem parametreleri doğrulama öznitelikleri de dahil olmak üzere herhangi bir özniteliği kullanamaz.

Geçici çözüm: Yöntem gövdesindeki parametreleri doğrulama özniteliğiyle yeniden atayın veya cmdlet'iyle Update-TypeData statik oluşturucuda yöntemini tanımlayın.
Yöntem parametreleri varsayılan değerleri tanımlayamaz. Parametreler her zaman zorunlu olmalıdır.

Geçici çözüm: cmdlet'iyle statik oluşturucuda Update-TypeData yöntemini tanımlayın.
Yöntemler gizli olsalar bile her zaman geneldir. Sınıf devralındığında bunlar geçersiz kılınabilir.

Geçici çözüm: Yok.
Bir yöntemin herhangi bir aşırı yüklemesi gizlenirse, bu yöntemin her aşırı yüklemesi de gizli olarak değerlendirilir.

Geçici çözüm: Yok.

Aracılığıyla paylaş