Sınıf Yöntemleri hakkında

Kısa açıklama

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

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 çıktı türünü tanımlar. Bir yöntem herhangi bir çıktı döndürmüyorsa Void çıktı türüne sahip olmalıdır. Bir yöntem açıkça bir çıktı türünü tanımlamıyorsa yöntemin çıktı türü Void olur.

Sınıf yöntemlerinde, return ifadesinde belirtilenler dışında hiçbir nesne ardışık düzene gönderilmez. Koddan boru hattına tesadüfi bir çıktı yoktur.

Bir sınıf yönteminin içinden hata akışına yazılan sonlanmayan hatalar aktarılmaz. Sonlandırma hatasını ortaya çıkarmak için throw komutunu kullanmalısınız. Write-* cmdlet'lerini kullanarak PowerShell'in çıktı akışlarına bir sınıf yöntemi içinden yazmaya devam edebilirsiniz. Cmdlet'ler çağrı kapsamındaki tercih değişkenlerine saygı duyar. Ancak, yöntemin yalnızca return ifadesini kullanarak nesnelerin çıktısını alması için Write-* cmdlet'lerini kullanmaktan kaçınmalısınız.

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 öznitelikler de dahil olmak üzere herhangi bir sayıda özniteliğe sahip olabilir.

Sözdizimi

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

Tek satırlık sözdizimi

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

Çok satırlı sözdizimi

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

Örnekler

Örnek 1 - Minimal yöntem tanımı

ExampleCube1 sınıfının GetVolume() yöntemi, küpün hacmini döndürür. Çıkış türünü kayan sayı olarak tanımlar ve örneğin Height, Length ve Width özelliklerinin çarpılması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()

12

Örnek 2 - Parametreli yöntem

GeWeight() yöntemi, küpün yoğunluğu için kayan bir sayı girişi alır ve hacmin yoğunlukla çarpımı olarak hesaplanan küpün 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)

30

Örnek 3 - Çıktısız yöntem

Bu örnek, System.Void çıkış türüyle Validate() yöntemini tanımlar. Bu yöntem hiçbir çıktı döndürmez. Bunun yerine, doğrulama başarısız olursa bir hata verir. GetVolume() yöntemi, küpün hacmini hesaplamadan önce Validate() öğesini çağırır. Doğrulama başarısız olursa yöntem hesaplamadan önce sonlandırılı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.

Yöntem, Height ve Width özelliklerinin geçersiz olması ve sınıfın geçerli hacmi hesaplamasını engellemesi nedeniyle bir istisna atar.

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

ExampleCube4 sınıfı, iki aşırı yüklemeyle GetVolume() statik yöntemini tanımlar. İlk aşırı yüklemede küpün boyutlarına ilişkin parametreler ve yöntemin girişi doğrulaması gerekip gerekmediğini gösteren bir bayrak bulunur.

İkinci aşırı yük yalnızca sayısal girişleri içerir. $Static ile yapılan ilk aşırı yüklemeyi $true olarak çağırır. İkinci aşırı yükleme, kullanıcılara her zaman girdinin kesin olarak doğrulanıp doğrulanmayacağını tanımlamak zorunda kalmadan yöntemi çağırmanın bir yolunu sağlar.

Sınıf ayrıca GetVolume()'u örnek (statik olmayan) yöntem olarak tanımlar. Bu yöntem, ikinci statik aşırı yüklemeyi çağırarak GetVolume() örneği yönteminin, çıktı değerini döndürmeden önce her zaman küpün boyutlarını 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ı mesajlar, $this.GetVolume()'a yapılan ilk çağrının statik yöntemi nasıl çağırdığını gösterir.

Statik yöntemi doğrudan Strict parametresiyle $false olarak çağırmak, birim için 0 değerini 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üklemeler

Her sınıf yönteminin, yöntemin nasıl çağrılacağını tanımlayan benzersiz bir imzası vardır. Yöntemin çıktı türü, adı ve parametreleri yöntem imzasını tanımlar.

Bir sınıf aynı isimde birden fazla yöntem tanımladığında, o yöntemin tanımları aşırı yükleme olur. Bir yönteme yönelik aşırı yüklemelerin farklı parametrelere sahip olması gerekir. Çıkış türleri farklı olsa bile bir yöntem aynı parametrelerle iki uygulamayı tanımlayamaz.

Aşağıdaki sınıf iki yöntemi tanımlar: Shuffle() ve Deal(). Deal() yöntemi, biri parametresiz, diğeri Count parametreli olmak üzere iki aşırı yüklemeyi 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 çıktısı

Varsayılan olarak yöntemlerin herhangi bir çıktısı yoktur. Bir yöntem imzası Void dışında açık bir çıktı türü içeriyorsa yöntemin bu türde bir nesne döndürmesi gerekir. Yöntemler, return anahtar sözcüğünün açıkça bir nesneyi döndürmesi dışında herhangi bir çıktı 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ş parantezler yöntemin parametre gerektirmediğini gösterir.

Parametreler tek satırda veya birden fazla satırda tanımlanabilir. Aşağıdaki bloklar yöntem parametrelerinin sözdizimini gösterir.

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

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

Yöntem parametreleri güçlü bir şekilde yazılabilir. Bir parametre yazılmazsa yöntem, o parametre için herhangi bir nesneyi kabul eder. Parametre yazılırsa, yöntem bu parametrenin değerini doğru türe dönüştürmeye çalışır ve giriş dönüştürülemezse bir istisna atar.

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

Yöntem parametrelerinin başka hiçbir özelliği olamaz. Bu, yöntemlerin Validate* özniteliklerine sahip 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 kalıplardan birini kullanabilirsiniz:

1. Parametreleri gerekli doğrulama öznitelikleriyle aynı değişkenlere yeniden atayın. Bu hem statik hem de örnek yöntemler için işe yarar. Bu modelin bir örneği için Örnek 4'e bakın.
2. Doğrudan parametrelerdeki doğrulama niteliklerini kullanan bir ScriptMethod tanımlamak için Update-TypeData'yı kullanın. Bu yalnızca örnek yöntemler için işe yarar. 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

Otomatik değişkenlerin tümü yöntemlerde mevcut değildir. Aşağıdaki listede otomatik değişkenler ve bunların PowerShell sınıfı yöntemlerinde kullanılıp kullanılmayacağı ve nasıl kullanılacağına ilişkin öneriler yer almaktadır. Listede yer almayan otomatik değişkenler sınıf yöntemlerinde 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 şekilde erişin.
• $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 şekilde erişin.
• $MyInvokasyon - Normal erişim.
• $NestedPromptLevel - Normal şekilde erişin.
• $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. Bir sınıfta kullanılması beklenmeyen yan etkilere neden olabilir.
• $PSCmdlet - Bu değişkeni kullanmayın. Cmdlet'ler ve işlevler için tasarlanmıştır. Bir sınıfta kullanılması beklenmeyen yan etkilere neden olabilir.
• $PSCommandPath - Normal şekilde erişin.
• $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. Bir sınıf yönteminde $this her zaman sınıfın geçerli örneğidir. Bununla sınıf özelliklerine ve yöntemlerine erişebilirsiniz. Statik yöntemlerde mevcut değildir.
• $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'inin döndürdüğü sınıf üyeleri listesine dahil edilmez. Get-Member ile gizli yöntemleri göstermek için Force parametresini kullanın.
• Tamamlama gizli yöntemi tanımlayan sınıfta gerçekleşmediği sürece sekme tamamlamada veya IntelliSense'te görüntülenmez.
• Sınıfın genel üyeleri. Çağrılabilir ve miras alınabilirler. Bir yöntemi gizlemek onu gizli yapmaz. Yalnızca önceki noktalarda açıklandığı gibi yöntemi gizler.

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

Statik yöntemler

Yöntemi static anahtar sözcüğüyle bildirerek, bir yöntemi sınıfın örnekleri yerine sınıfın kendisine ait olacak şekilde tanımlayabilirsiniz. Statik sınıf yöntemleri:

• Sınıf örneklemesinden bağımsız olarak her zaman kullanılabilir.
• Sınıfın tüm örneklerinde paylaşılır.
• Her zaman mevcuttur.
• Sınıfın örnek özelliklerine erişilemiyor. Yalnızca statik özelliklere erişebilirler.
• Tüm oturum süresi boyunca canlı kalın.

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üklerini miras alı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 mevcuttur.

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ük için çıkış tipi farklı olabilir.

Yapıcılardan farklı olarak yöntemler, yöntem için temel sınıf aşırı yüklemesini çağırmak amacıyla : base() sözdizimini kullanamaz. Türetilmiş sınıftaki yeniden tanımlanan aşırı yük, temel sınıf tarafından tanımlanan aşırı yükün tamamen yerini alır.

Aşağıdaki örnek, türetilmiş sınıflardaki statik ve örnek yöntemlerin davranışını gösterir.

Temel sınıf şunları tanımlar:

• Geçerli saati döndürmek için Now() ve geçmişteki bir tarihi döndürmek için DaysAgo() statik yöntemleri.
• Örnek özelliği TimeStamp ve bu özelliğin dize gösterimini döndüren bir ToString() örnek yöntemi. Bu, bir örnek bir dizede kullanıldığında, sınıf adı yerine tarihsaat dizesine dönüştürülmesini sağlar.
• İki aşırı yüklemeli SetTimeStamp() örnek yöntemi. Yöntem parametresiz çağrıldığında TimeStamp'ı geçerli saate ayarlar. Yöntem bir DateTime ile ç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, BaseClass'tan türetilen sınıfları tanımlar:

• DerivedClassA, herhangi bir geçersiz kılma olmaksızın BaseClass'tan devralır.
• DerivedClassB, DateTime nesnesi yerine bir dize gösterimi döndürmek için DaysAgo() statik yöntemini geçersiz kılar. Ayrıca zaman damgasını ISO8601 tarih dizesi olarak döndürmek için ToString() örnek yöntemini de geçersiz kılar.
• DerivedClassC, SetTimeStamp() yönteminin parametresiz aşırı yüklemesini geçersiz kılar, böylece zaman damgasının parametresiz ayarlanması, 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ımlanan sınıflar için statik Now() yönteminin çıktısını gösterir. Türetilmiş sınıflar, yöntemin temel sınıf uygulamasını geçersiz kılmadığı için çıktı 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. Temel uygulamayı geçersiz kıldığından yalnızca DerivedClassB'nin çıktısı farklıdır.

"[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'nin gösterimi farklıdır çünkü ToString() örnek yöntemini geçersiz kılmıştı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() örnek yöntemini çağırarak TimeStamp özelliğini belirli bir tarihe ayarlar. Türetilmiş sınıfların hiçbiri yöntem için parametreli aşırı yüklemeyi geçersiz kılmadığı için 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 önceye 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şturucuda bir sınıfın örnekleri için yöntemler tanımlayabilirsiniz.

Bu parçayı model için bir başlangıç noktası olarak kullanın. Açılı parantez 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
        }
    }
}

Varsayılan parametre değerleri ve doğrulama nitelikleriyle 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 niteliklerini tanımlayamaz. Varsayılan değerlere veya doğrulama özelliklerine sahip sınıf yöntemlerini tanımlamak için bunların ScriptMethod üyeleri olarak tanımlanması gerekir.

Bu örnekte, CardDeck sınıfı, Count parametresi için hem doğrulama özelliğini hem de varsayılan değeri kullanan bir Draw() yöntemini 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.

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 hiçbir özniteliği kullanamaz.

  Geçici çözüm: Yöntem gövdesindeki parametreleri doğrulama özniteliğiyle yeniden atayın veya yöntemi statik oluşturucuda Update-TypeData cmdlet'iyle tanımlayın.

• Yöntem parametreleri varsayılan değerleri tanımlayamaz. Parametreler her zaman zorunludur.

  Geçici Çözüm: Statik oluşturucudaki yöntemi Update-TypeData cmdlet'iyle tanımlayın.

• Yöntemler gizli olsalar bile her zaman herkese açıktır. Sınıf devralındığında geçersiz kılınabilirler.

  Geçici Çözüm: Yok.

• Bir yöntemin herhangi bir aşırı yüklemesi gizlenmişse, o yönteme ilişkin her aşırı yükleme de gizli olarak değerlendirilir.

  Geçici Çözüm: Yok.

Ayrıca bakınız

• about_Automatic_Variables
• about_Classes
• about_Classes_Constructors
• about_Classes_Inheritance
• about_Classes_Properties
• about_Using