Sınıflar_Yöntemler_Hakkında

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ştirebileceğ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, return deyiminde belirtilenler dışında işlem hattına hiçbir nesne gönderilmez. 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 throw kullanmanız gerekir. Write-* cmdlet'lerini kullanarak, sınıf yöntemi içinden PowerShell'in çıkış akışlarına yazmaya devam edebilirsiniz. Cmdlet'ler, arama kapsamında tercih değişkenlerine saygı gösterir. Ancak, yöntemin yalnızca Write-* deyimini kullanarak nesne çıkışı vermesi için return 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 $this otomatik değişkenini kullanarak sınıf nesnesinin geçerli örneğine başvurabilir. $this otomatik değişkeni statik yöntemlerde kullanılamaz.

Sınıf yöntemleri, gizli ve statik öznitelikleri dahil olmak üzere herhangi bir sayıda özniteliğe sahip olabilir.

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() 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 Height, Lengthve Width ö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

GeWeight() yöntemi, 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 Validate()olan yöntemini tanımlar. Bu yöntem çıkış döndürmez. Bunun yerine, doğrulama başarısız olursa bir hata oluşturur. GetVolume() yöntemi, küp hacmini hesaplamadan önce Validate() çağırır. 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 sınıfın geçerli birimi hesaplamasını önleyen bir özel durum oluşturur.

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

ExampleCube4 sınıfı iki aşırı yüklemeyle GetVolume() statik yöntemi 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. $Strict ile ilk aşırı yüklemeyi $trueolarak ç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ı ayrıca GetVolume() bir örnek (statik olmayan) yöntemi olarak tanımlar. 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, $this.GetVolume()'a yapılan ilk çağrının statik yöntemi nasıl çağıracaklarını gösterir.

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

[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üklemeler. 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, Shuffle() ve Deal()adlı iki yöntemi 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ı Voiddışında açık bir çıkış türü içeriyorsa, yöntemin bu tür bir nesnesi döndürmesi gerekir. return anahtar sözcüğü açıkça bir nesne döndürdüğü durumlar 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 Validate* öznitelikleriyle 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 öznitelikleri kullanan bir Update-TypeData tanımlamak için ScriptMethod kullanın. 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 $Script:ConsoleFileName olarak erişin.
$Error - Normal erişim.
$EnabledExperimentalFeatures - Bunun yerine $Script:EnabledExperimentalFeatures olarak erişin.
$Event - Normal erişim.
$EventArgs - Normal erişim.
$EventSubscriber - Normal erişim.
$ExecutionContext - Bunun yerine $Script:ExecutionContext olarak erişin.
$false - Normal erişim.
$foreach - Normal erişim.
$HOME - Bunun yerine $Script:HOME olarak erişin.
$Host - Bunun yerine $Script:Host olarak erişin.
$input - Bunun yerine açık parametre değişkenlerini kullanın.
$IsCoreCLR - Bunun yerine $Script:IsCoreCLR olarak erişin.
$IsLinux - Bunun yerine $Script:IsLinux olarak erişin.
$IsMacOS - Bunun yerine $Script:IsMacOS olarak erişin.
$IsWindows - Bunun yerine $Script:IsWindows olarak erişin.
$LASTEXITCODE - Normal erişim.
$Matches - Normal erişim.
$MyInvocation - Normal erişim.
$NestedPromptLevel - Normal erişim.
$null - Normal erişim.
$PID - Bunun yerine $Script:PID olarak erişin.
$PROFILE - Bunun yerine $Script:PROFILE olarak erişin.
$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 $Script:PSCulture olarak erişin.
$PSEdition - Bunun yerine $Script:PSEdition olarak erişin.
$PSHOME - Bunun yerine $Script:PSHOME olarak erişin.
$PSItem - Normal erişim.
$PSScriptRoot - Normal erişim.
$PSSenderInfo - Bunun yerine $Script:PSSenderInfo olarak erişin.
$PSUICulture - Bunun yerine $Script:PSUICulture olarak erişin.
$PSVersionTable - Bunun yerine $Script:PSVersionTable olarak erişin.
$PWD - Normal erişim.
$Sender - Normal erişim.
$ShellId - Bunun yerine $Script:ShellId olarak erişin.
$StackTrace - Normal erişim.
$switch - Normal erişim.
$this - Normal erişim. Sınıf yönteminde $this her zaman sınıfı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 hidden anahtar sözcüğüyle bildirerek gizleyebilirsiniz. Gizli sınıf yöntemleri şunlardır:

Get-Member cmdlet'i tarafından döndürülen sınıf üyeleri listesine dahil değildir. Get-Memberile gizli yöntemleri göstermek için Zorla 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öntem için herhangi bir aşırı yüklemeyi gizlediğinizde, bu yöntem IntelliSense'ten, tamamlanma sonuçlarından ve Get-Memberiçin varsayılan çıktıdan kaldırılır.

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

Statik yöntemler

yöntemini static anahtar sözcüğüyle 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 temel sınıf aşırı yüklemesini çağırmak için : base(<parameters>) 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:

Statik yöntemler geçerli saati döndürmek için Now() ve geçmişteki bir tarihi döndürmek için DaysAgo().
Örnek özelliği, TimeStamp ve bu özelliğin dize gösterimini döndüren bir ToString() örneği yöntemidir. Bu, bir dizede örnek kullanıldığında sınıf adı yerine datetime dizesine dönüştürülmesini sağlar.
Örnek yöntemi iki aşırı yüklemeyle SetTimeStamp(). Yöntemi parametresiz çağrıldığında, TimeStamp geçerli saate ayarlar. yöntemi bir DateTimeile çağrıldığında, TimeStamp 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, BaseClasstüretilen sınıfları tanımlar:

DerivedClassA herhangi bir geçersiz kılma olmadan BaseClass devralır.
DerivedClassB, DaysAgo() nesnesi yerine dize gösterimi döndürmek için statik yöntemini geçersiz kılar. Ayrıca zaman damgasını ISO8601 tarih dizesi olarak döndürmek için ToString() örneği yöntemini geçersiz kılar.
DerivedClassC, SetTimeStamp() yönteminin parametresiz aşırı yüklemesini 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önteminin çı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, ToString() örnek yönteminin üzerine geçtiğinden 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 SetTimeStamp() örneği yöntemini çağırır 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 herhangi bir parametre olmadan SetTimeStamp() çağırır. Çıktı, 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, Update-TypeData cmdlet'ini kullanarak statik oluşturucudaki bir sınıfın ö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
        }
    }
}

Bahşiş

Add-Member cmdlet'i statik olmayan oluşturuculardaki bir sınıfa özellik ve yöntemler ekleyebilir, ancak oluşturucu her çağrıldığında cmdlet çalışır. Statik oluşturucuda Update-TypeData kullanılması, 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ı, Draw() parametresi için hem doğrulama özniteliği hem de varsayılan değer kullanan bir yöntemi tanımlar.

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 Update-TypeData cmdlet'iyle 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: Update-TypeData cmdlet'iyle statik oluşturucuda 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.

Ayrıca bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-02-05