ShouldProcess hakkında bilmek istediğiniz her şey

PowerShell işlevleri, kullanıcıların bunlarla etkileşim kurma şeklini büyük ölçüde geliştiren çeşitli özelliklere sahiptir. Göz ardı edilen önemli özelliklerden biri -WhatIf ve -Confirm desteğidir ve bu, işlevlerinize kolayca eklenebilir. Bu makalede, bu özelliği nasıl uygulayacağımıza ayrıntılı bir şekilde göz atacağız.

Bu, işlevlerinizde etkinleştirebileceğiniz basit bir özelliktir ve ihtiyaç duyan kullanıcılara bir güvenlik ağı sağlar. İlk kez tehlikeli olabileceğini bildiğiniz bir komutu çalıştırmaktan daha korkutucu bir şey yoktur. Ile -WhatIf çalıştırma seçeneği büyük bir fark oluşturabilir.

Ortak Parametreler

Bu ortak parametreleri uygulamaya geçmeden önce bunların nasıl kullanıldığına hızlıca bakmak istiyorum.

-WhatIf kullanımını

Bir komut parametresini desteklediğinde -WhatIf , değişiklik yapmak yerine komutun ne yapacağını görmenize olanak tanır. özellikle yıkıcı bir şey gerçekleştirmeden önce komutun etkisini test etmek için iyi bir yoldur.

PS C:\temp> Get-ChildItem
    Directory: C:\temp
Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         4/19/2021   8:59 AM              0 importantfile.txt
-a----         4/19/2021   8:58 AM              0 myfile1.txt
-a----         4/19/2021   8:59 AM              0 myfile2.txt

PS C:\temp> Remove-Item -Path .\myfile1.txt -WhatIf
What if: Performing the operation "Remove File" on target "C:\Temp\myfile1.txt".

Eğer komut ShouldProcess'i doğru şekilde uygularsa, yapacağı tüm değişiklikleri size göstermelidir. Birden çok dosyayı silmek için joker karakter kullanan bir örnek aşağıda verilmiştir.

PS C:\temp> Remove-Item -Path * -WhatIf
What if: Performing the operation "Remove File" on target "C:\Temp\myfile1.txt".
What if: Performing the operation "Remove File" on target "C:\Temp\myfile2.txt".
What if: Performing the operation "Remove File" on target "C:\Temp\importantfile.txt".

-Confirm komutunu kullanma

-WhatIf destekleyen komutlar aynı zamanda -Confirm de destekler. Bu size bir eylemi gerçekleştirmeden önce onaylama şansı verir.

PS C:\temp> Remove-Item .\myfile1.txt -Confirm

Confirm
Are you sure you want to perform this action?
Performing the operation "Remove File" on target "C:\Temp\myfile1.txt".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

Bu durumda, devam etme, bir değişikliği atlama veya betiği durdurmanıza olanak sağlayan birden çok seçeneğiniz vardır. Yardım isteminde bu seçeneklerin her biri şöyle açıklanmaktadır.

Y - Continue with only the next step of the operation.
A - Continue with all the steps of the operation.
N - Skip this operation and proceed with the next operation.
L - Skip this operation and all subsequent operations.
S - Pause the current pipeline and return to the command prompt. Type "exit" to resume the pipeline.
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

Yerelleştirme

Bu istem PowerShell'de yerelleştirildiğinden dil, işletim sisteminizin diline göre değişir. Bu, PowerShell'in sizin için yönettiği bir şeydir.

[switch] Parametreler

Değerleri bir [switch] parametresine geçirmenin yollarını incelemek için kısa bir süre ayıralım. Bunu belirtmemin ana nedeni, parametre değerlerini çağırdığınız işlevlere sık sık geçirmek istemenizdir.

İlk yaklaşım, tüm parametreler için kullanılabilecek belirli bir parametre söz dizimidir, ancak çoğunlukla parametreler için [switch] kullanıldığını görürsünüz. Parametresine bir değer eklemek için iki nokta üst üste belirtirsiniz.

Remove-Item -Path:* -WhatIf:$true

Aynı işlemi bir değişkenle de yapabilirsiniz.

$DoWhatIf = $true
Remove-Item -Path * -WhatIf:$DoWhatIf

İkinci yaklaşım, değeri yaymak için bir karma tablo kullanmaktır.

$RemoveSplat = @{
    Path = '*'
    WhatIf = $true
}
Remove-Item @RemoveSplat

Hashtable'lara veya splat kullanmaya yeniyseniz, hashtablolar hakkında bilmek istediğiniz her şeyi kapsayan başka bir makalem var.

Şu Anlamda Destekler: İşlenecek

İşlevinizin -WhatIf içinde -Confirm belirtmek SupportsShouldProcess ve CmdletBinding desteğini etkinleştirmek için ilk adımdır.

function Test-ShouldProcess {
    [CmdletBinding(SupportsShouldProcess)]
    param()
    Remove-Item .\myfile1.txt
}

Bu şekilde SupportsShouldProcess belirterek, -WhatIf (veya -Confirm) ile işlevimizi çağırabiliriz.

PS> Test-ShouldProcess -WhatIf
What if: Performing the operation "Remove File" on target "C:\Temp\myfile1.txt".

adlı -WhatIfbir parametre oluşturmadığıma dikkat edin. SupportsShouldProcess belirtmek, onu bizim için otomatik olarak oluşturur. parametresini -WhatIf üzerinde Test-ShouldProcess belirttiğimizde, çağırdığımız bazı şeyler de -WhatIf işlemi gerçekleştirir.

Güven ama doğrula

Burada, çağırdığınız her şeyin -WhatIf değerlerini devraldığına güvenmek bir tehlike içeriyor. Örneklerin geri kalanında, bunun çalışmadığını varsayacak ve diğer komutlara çağrı yaparken çok belirgin olmaya özen göstereceğim. Ben de aynısını yapmanızı tavsiye ederim.

function Test-ShouldProcess {
    [CmdletBinding(SupportsShouldProcess)]
    param()
    Remove-Item .\myfile1.txt -WhatIf:$WhatIfPreference
}

Tüm parçaları daha iyi anladıktan sonra nüanslara çok daha sonra döneceğim.

$PSCmdlet.ShouldProcess

Uygulamanıza SupportsShouldProcess olanak tanıyan yöntemdir $PSCmdlet.ShouldProcess. Bir mantığı işlemeniz gerekip gerekmediğini görmek için arama $PSCmdlet.ShouldProcess(...) yaptığınızda PowerShell gerisini halleder. Bir örnekle başlayalım:

function Test-ShouldProcess {
    [CmdletBinding(SupportsShouldProcess)]
    param()

    $file = Get-ChildItem './myfile1.txt'
    if($PSCmdlet.ShouldProcess($file.Name)){
        $file.Delete()
    }
}

$PSCmdlet.ShouldProcess($file.Name) çağrısı -WhatIf (ve -Confirm parametresini) denetler ve buna göre işler. -WhatIf öğesi, ShouldProcess'in değişikliğin açıklamasını çıktıya vermesine ve $false'i döndürmesine neden olur.

PS> Test-ShouldProcess -WhatIf
What if: Performing the operation "Test-ShouldProcess" on target "myfile1.txt".

-Confirm kullanılarak yapılan bir çağrı, betiği duraklatır ve kullanıcıya devam etme seçeneği sunar. Kullanıcı $true öğesini seçtiyse, Y döndürür.

PS> Test-ShouldProcess -Confirm
Confirm
Are you sure you want to perform this action?
Performing the operation "Test-ShouldProcess" on target "myfile1.txt".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

$PSCmdlet.ShouldProcess'ün mükemmel bir özelliği, aynı zamanda ayrıntılı çıktı sağlamasıdır. ShouldProcess uygularken buna sıkça güvenirim.

PS> Test-ShouldProcess -Verbose
VERBOSE: Performing the operation "Test-ShouldProcess" on target "myfile1.txt".

Aşırı Yüklemeler

Mesajlaşmayı özelleştirmek için $PSCmdlet.ShouldProcess farklı parametrelerle birkaç farklı aşırı yükleme vardır. Yukarıdaki örnekte ilkini zaten gördük. Şimdi daha yakından bakalım.

function Test-ShouldProcess {
    [CmdletBinding(SupportsShouldProcess)]
    param()

    if($PSCmdlet.ShouldProcess('TARGET')){
        # ...
    }
}

Bu, hem işlev adını hem de hedefi (parametrenin değeri) içeren bir çıkış oluşturur.

What if: Performing the operation "Test-ShouldProcess" on target "TARGET".

İşlem olarak ikinci bir parametre belirtmek, iletideki işlev adı yerine işlem değerini kullanır.

## $PSCmdlet.ShouldProcess('TARGET','OPERATION')
What if: Performing the operation "OPERATION" on target "TARGET".

Sonraki seçenek, iletiyi tamamen özelleştirmek için üç parametre belirtmektir. Üç parametre kullanıldığında, birincisi bütün mesajdır. İkinci iki parametre yine ileti çıkışında -Confirm kullanılır.

## $PSCmdlet.ShouldProcess('MESSAGE','TARGET','OPERATION')
What if: MESSAGE

Hızlı parametre referansı

Buraya yalnızca hangi parametreleri kullanmanız gerektiğini bulmak için gelmiş olmanız durumunda, parametrelerin farklı -WhatIf senaryolarda iletiyi nasıl değiştireceğini gösteren hızlı bir başvuru aşağıda verilmiştir.

## $PSCmdlet.ShouldProcess('TARGET')
What if: Performing the operation "FUNCTION_NAME" on target "TARGET".

## $PSCmdlet.ShouldProcess('TARGET','OPERATION')
What if: Performing the operation "OPERATION" on target "TARGET".

## $PSCmdlet.ShouldProcess('MESSAGE','TARGET','OPERATION')
What if: MESSAGE

İki parametreli olanı kullanma eğilimindeyim.

ShouldProcessReason

Diğerlerinden daha gelişmiş bir dördüncü kapasite aşımımız var. Bu, ShouldProcess'nin neden yürütüldüğünü öğrenmenizi sağlar. Bunu buraya yalnızca tamlık olması için ekliyorum çünkü bunun yerine $WhatIfPreference'nin $true olup olmadığını kontrol edebiliriz.

$reason = ''
if($PSCmdlet.ShouldProcess('MESSAGE','TARGET','OPERATION',[ref]$reason)){
    Write-Output "Some Action"
}
$reason

$reason değişkenini, [ref] ile başvuru değişkeni olarak dördüncü parametreye geçirmemiz gerekir. ShouldProcess, $reason veya None değeriyle WhatIf doldurur. Bunun yararlı olduğunu söylemedim ve kullanmak için hiçbir nedenim yoktu.

Nereye yerleştirileceği

ShouldProcess kullanarak betiklerinizi daha güvenli hale getirirsiniz. Bu nedenle, betikleriniz değişiklik yaparken bunu kullanırsınız. Değişikliğe mümkün olduğunca yakın bir yere $PSCmdlet.ShouldProcess aramayı yerleştirmek istiyorum.

## general logic and variable work
if ($PSCmdlet.ShouldProcess('TARGET','OPERATION')){
    # Change goes here
}

Bir öğe koleksiyonunu işliyorsam, her öğe için onu çağırıyorum. Böylece çağrı döngünün foreach içine yerleştirilir.

foreach ($node in $collection){
    # general logic and variable work
    if ($PSCmdlet.ShouldProcess($node,'OPERATION')){
        # Change goes here
    }
}

Değişikliğin etrafına ShouldProcess'ı sıkıca yerleştirmemin nedeni, -WhatIf belirtildiğinde mümkün olduğunca çok kodun çalışmasını istememdir. Kullanıcının bu hataları görebilmesi için mümkünse kurulum ve doğrulamanın çalışmasını istiyorum.

Ayrıca projelerimi doğrulayan Pester testlerinde de bunu kullanmak istiyorum. Pester'da mock yapmanın zor olduğu bir mantık parçam varsa, genellikle onu ShouldProcess ile sarıp testlerimde -WhatIf ile çağırabilirim. Kodunuzun bir kısmını test etmek, hiçbirini test etmekten daha iyidir.

$WhatIfPreference

sahip olduğumuz ilk tercih değişkenidir $WhatIfPreference. Varsayılan olarak budur $false . bunu $true olarak ayarlarsanız, işleviniz belirttiğiniz -WhatIfgibi yürütülür. Oturumunuzda bunu ayarlarsanız, tüm komutlar -WhatIf yürütülür.

Bir işlevi -WhatIf ile çağırdığınızda, $WhatIfPreference'nin değeri, işlevinizin kapsamı içinde $true olarak ayarlanır.

ConfirmImpact

Örneklerimin çoğu -WhatIf içindir, ancak şu ana kadarki her şey, kullanıcıyı yönlendirmek için -Confirm ile de çalışır. İşlevin ConfirmImpact değerini yüksek olarak ayarlayabilirsiniz ve bu, sanki -Confirm ile çağrılmış gibi kullanıcıya bir uyarı verir.

function Test-ShouldProcess {
    [CmdletBinding(
        SupportsShouldProcess,
        ConfirmImpact = 'High'
    )]
    param()

    if ($PSCmdlet.ShouldProcess('TARGET')){
        Write-Output "Some Action"
    }
}

Bu çağrı Test-ShouldProcess, -Confirm etkisi nedeniyle High eylemini gerçekleştiriyor.

PS> Test-ShouldProcess

Confirm
Are you sure you want to perform this action?
Performing the operation "Test-ShouldProcess" on target "TARGET".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): y
Some Action

Belirgin sorun, artık kullanıcıya sormadan diğer betiklerde kullanmanın daha zor olmasıdır. Bu durumda, istemi bastırmak için $false'yi -Confirm'ye geçirebiliriz.

PS> Test-ShouldProcess -Confirm:$false
Some Action

Daha sonraki bir bölümde -Force desteği ekleme konusunu ele alacağım.

$ConfirmPreference

$ConfirmPreference, ConfirmImpact'in yürütmeyi onaylamanızı isteme zamanını kontrol eden otomatik bir değişkendir. İşte $ConfirmPreference ve ConfirmImpact için olası değerler.

• High
• Medium
• Low
• None

Bu değerlerle her işlev için farklı etki düzeyleri belirtebilirsiniz. Eğer $ConfirmPreferenceyi ConfirmImpactden daha yüksek bir değere ayarladıysanız, yürütmeyi onaylamanız istenmez.

Varsayılan olarak, $ConfirmPreferenceHigh olarak ayarlanır ve ConfirmImpactMedium olur. İşlevinizin kullanıcıya otomatik olarak sormasını istiyorsanız, ConfirmImpact öğesini High olarak ayarlayın. Aksi takdirde yıkıcıysa Medium olarak ayarlayın ve komutun her zaman üretimde çalıştırılması güvenliyse Low kullanın. none olarak ayarlarsanız, -Confirm belirtilmiş olsa bile size sormaz (ancak yine de size -WhatIf desteği verir).

Bir işlev -Confirm ile çağrıldığında, işlevinizin kapsamında $ConfirmPreference'in değeri Low olarak ayarlanır.

İç içe geçmiş onay istemlerini gizleme

$ConfirmPreference çağırdığınız işlevler tarafından kullanılabiliyor. Bu, onay istemi eklediğiniz ve çağırdığınız işlevin kullanıcıya da sorduğu senaryolar oluşturabilir.

Komut satırındaki istemleri zaten ele aldıktan sonra çağırdığım komutlarda genellikle -Confirm:$false belirtirim.

function Test-ShouldProcess {
    [CmdletBinding(SupportsShouldProcess)]
    param()

    $file = Get-ChildItem './myfile1.txt'
    if($PSCmdlet.ShouldProcess($file.Name)){
        Remove-Item -Path $file.FullName -Confirm:$false
    }
}

Bu, bizi önceki bir uyarıya geri getirir: -WhatIf'ün bir işleve ne zaman geçirilmediği ve -Confirm'in bir işleve ne zaman geçirildiğiyle ilgili nüanslar vardır. Söz veriyorum, bu işi daha sonra yapacağım.

$PSCmdlet.ShouldContinue

Sağladığından ShouldProcess daha fazla denetime ihtiyacınız varsa, istemi doğrudan ile ShouldContinuetetikleyebilirsiniz. ShouldContinue, $ConfirmPreference, ConfirmImpact, -Confirm, $WhatIfPreference ve -WhatIf değerlerini yoksayar çünkü her yürütüldüğünde bunu ister.

Hızlı bir bakışta, ShouldProcess ve ShouldContinue'yi kolayca karıştırmak mümkündür. ShouldProcess kullanmayı hatırlama eğilimindeyim çünkü SupportsShouldProcess içinde CmdletBinding olarak adlandırılıyor. Hemen her senaryoda kullanmanız ShouldProcess gerekir. Bu yüzden önce bu yöntemi ele aldım.

Şimdi ShouldContinue'yi iş başında görelim.

function Test-ShouldContinue {
    [CmdletBinding()]
    param()

    if($PSCmdlet.ShouldContinue('TARGET','OPERATION')){
        Write-Output "Some Action"
    }
}

Bu, daha az seçenek içeren daha basit bir istem sağlar.

Test-ShouldContinue

OPERATION
TARGET
[Y] Yes  [N] No  [S] Suspend  [?] Help (default is "Y"):

En büyük sorun ShouldContinue , her zaman kullanıcıya sorduğundan, kullanıcının etkileşimli olarak çalıştırmasını gerektirmesidir. Her zaman diğer betikler tarafından kullanılabilecek araçlar oluşturmanız gerekir. Bunu yapmanın yolu, -Force uygulamaktır. Bu fikri daha sonra yeniden ele alacağım.

Tümüne evet

Bu, ShouldProcess ile otomatik olarak işlenir ancak ShouldContinue için biraz daha fazla çalışma yapmamız gerekir. Mantığı kontrol etmek için birkaç değeri referans olarak geçirmemiz gereken ikinci bir yöntem aşırı yüklemesi vardır.

function Test-ShouldContinue {
    [CmdletBinding()]
    param()

    $collection = 1..5
    $yesToAll = $false
    $noToAll = $false

    foreach($target in $collection) {

        $continue = $PSCmdlet.ShouldContinue(
                "TARGET_$target",
                'OPERATION',
                [ref]$yesToAll,
                [ref]$noToAll
            )

        if ($continue){
            Write-Output "Some Action [$target]"
        }
    }
}

Bir foreach döngü ve bunu çalışırken göstermek için bir koleksiyon ekledim. Okunmasını kolaylaştırmak için ShouldContinue ifadenin içinden if aramayı çıkardım. Dört parametreli bir yöntemi çağırmak biraz çirkin olmaya başlar, ancak olabildiğince temiz görünmesini sağlamaya çalıştım.

Zorla Uygulama

ShouldProcess ve ShouldContinue, -Force'yi farklı biçimlerde uygulamalıdır. Bu uygulamaların püf noktası, ShouldProcess'nin her zaman yürütülmesi gerektiği, ancak ShouldContinue belirtildiğinde -Force'in yürütülmemesi gerektiğidir.

İşlemYapılmalı -Zorla

Eğer ConfirmImpact öğesini high olarak ayarlarsanız, kullanıcılarınızın deneyeceği ilk şey -Force ile bunu bastırmak olacaktır. Zaten ilk yaptığım şey bu.

Test-ShouldProcess -Force
Error: Test-ShouldProcess: A parameter cannot be found that matches parameter name 'force'.

Bölümünden ConfirmImpact hatırlayacağınız gibi, bu bölümü şu şekilde çağırmaları gerekir:

Test-ShouldProcess -Confirm:$false

Herkes bunu yapması gerektiğinin farkında değildir ve -Force gizlemez ShouldContinue. Bu nedenle kullanıcılarımızın akıl sağlığı için uygulamamız -Force gerekir. Buradaki tam örneğe göz atın:

function Test-ShouldProcess {
    [CmdletBinding(
        SupportsShouldProcess,
        ConfirmImpact = 'High'
    )]
    param(
        [switch]$Force
    )

    if ($Force -and -not $PSBoundParameters.ContainsKey('Confirm')) {
        $ConfirmPreference = 'None'
    }

    if ($PSCmdlet.ShouldProcess('TARGET')) {
        Write-Output "Some Action"
    }
}

Kendi -Force anahtarımızı parametre olarak ekleriz. -Confirm SupportsShouldProcess içinde kullanıldığında, CmdletBinding parametresi otomatik olarak eklenir. Ancak, SupportsShouldProcess kullandığınızda, PowerShell işlevine $Confirm değişkeni eklemez. Katı Modda çalıştırıyorsanız ve $Confirm değişkenini tanımlanmadan önce kullanmayı denerseniz, bir hata alırsınız. Hatadan kaçınmak için parametresinin kullanıcı tarafından geçirilip geçirilmediğini test etmek için kullanabilirsiniz $PSBoundParameters .

if ($Force -and -not $PSBoundParameters.ContainsKey('Confirm')) {
    $ConfirmPreference = 'None'
}

Kullanıcı -Force belirttiğinde, yerel kapsamda $ConfirmPreference'i None olarak ayarlarız. Kullanıcı ayrıca -Confirm belirtirse, ShoudProcess(), -Confirm parametresinin değerlerini kabul eder.

if ($PSCmdlet.ShouldProcess('TARGET')){
    Write-Output "Some Action"
}

Birisi hem -Force hem de -WhatIf belirtirse, -WhatIf önceliğe sahip olmalıdır. Bu yaklaşım -WhatIf işlemesini korur çünkü ShouldProcess her zaman yürütülür.

$Force ile if deyimi içine ShouldProcess değeri için bir test eklemeyin. Bu, bu senaryo için bir anti-paterndir, ancak sonraki bölümde ShouldContinue için size bunu gösteriyorum.

ShouldContinue -Force

Bu, -Force ve ShouldContinue ile uygulamanın doğru yoludur.

function Test-ShouldContinue {
    [CmdletBinding()]
    param(
        [switch]$Force
    )

    if($Force -or $PSCmdlet.ShouldContinue('TARGET','OPERATION')){
        Write-Output "Some Action"
    }
}

$Force öğesini -or operatörünün soluna yerleştirerek, önce bunun değerlendirilmesini sağlarsınız. Bu şekilde yazmak, if ifadesinin yürütülmesini kısa devre yapar. Eğer $Force$true ise, o zaman ShouldContinue yürütülmez.

PS> Test-ShouldContinue -Force
Some Action

Bu senaryoda -Confirm veya -WhatIf hakkında endişelenmemize gerek yok çünkü ShouldContinue tarafından desteklenmiyorlar. Bu nedenle ShouldProcess'den farklı şekilde işlenmesi gerekir.

Kapsam sorunları

-WhatIf ve -Confirm kullanımı, işlevlerinizin içindeki her şeye ve onların çağırdığı her şeye uygulanmalıdır. Bunu, $WhatIfPreference'i $true olarak ayarlayarak veya $ConfirmPreference'yi Low olarak ayarlayarak işlevin yerel kapsamı içinde yaparlar. Başka bir işlev çağırdığınızda, ShouldProcess bu değerleri kullanır.

Bu aslında çoğu zaman düzgün çalışır. Yerleşik cmdlet'i veya aynı kapsamdaki bir işlevi her çağırdığınızda çalışır. Ayrıca, bir betik modülünde bir betiği veya işlevi konsoldan çağırdığınızda da çalışır.

Belirli bir koşulda çalışmadığı yer, bir betik veya betik modülünün başka bir betik modülündeki bir işlevi çağırdığı zamandır. Bu büyük bir sorun gibi görünmeyebilir, ancak PSGallery'de oluşturduğunuz veya çıkardığınız modüllerin çoğu betik modülleridir.

Temel sorun, betik modüllerinin diğer betik modüllerindeki işlevlerden çağrıldıklarında $WhatIfPreference veya $ConfirmPreference (ve birkaç diğerinin) değerlerini devralmamalarıdır.

Bunu genel bir kural olarak özetlemenin en iyi yolu, bunun ikili modüller için doğru çalıştığını ve betik modülleri için çalışacağına asla güvenilmemesi gerektiğini söylemektir. Emin değilseniz test edin veya düzgün çalışmadığından emin olun.

Şahsen bunun çok tehlikeli olduğunu düşünüyorum çünkü yalıtıldığında doğru şekilde çalışan ancak birbirini çağırdığında düzgün çalışmayan birden fazla modüle -WhatIf desteği eklediğiniz senaryolar oluşturuyor.

Bu sorunu gidermek için çalışan bir GitHub RFC'miz var. Daha fazla ayrıntı için Betik modülü kapsamının ötesine yürütme tercihlerini yayma konusuna bakın.

Sonuç olarak

Her ihtiyacım olduğunda nasıl kullanacağımı ShouldProcess aramam gerekiyor. ShouldProcess ile ShouldContinue'i ayırt etmek uzun zamanımı aldı. Neredeyse her zaman hangi parametrelerin kullanılacağını aramam gerekir. Zaman zaman kafanız karışırsa endişelenmeyin. İhtiyacınız olduğunda bu makale burada olacaktır. Eminim sık sık ona başvuracağım.

Bu gönderiyi beğendiyseniz, lütfen aşağıdaki bağlantıyı kullanarak düşüncelerinizi Twitter'da benimle paylaşın. İçeriğimden değer alan kişilerden her zaman haber almayı severim.