PowerShell Sınıfları: Başlarken

PowerShell nesne yönelimli bir dildir. Komutları çalıştırdığınızda ekranınızdaki çıktıyı görün, bunlar nesnelerdir. Nesneler öylece yoktan gelmiyor; geliştiriciler bunları yaratır veya daha spesifik olarak bunları sınıflarla somutlaştırır. PowerShell sınıfları bu nesnelerin tanımlarını veya şemalarını temsil eder.

New-Object gibi komutlarla nesneler oluşturmaya ve pscustomobject tipi hızlandırıcıyı kullanmaya aşina olsanız da, bunlar "yeni" nesneler değildir. Bu yöntemlerin ürettiği nesne türleri belirli bir türdedir. PowerShell sınıfları türünü tanımlar.

Bu eğitimde PowerShell sınıflarına nasıl başlayacağınızı öğreneceksiniz. Yapıcılarla ilk sınıfınızı oluşturacak, sınıfınızdan nasıl nesneler oluşturacağınızı öğrenecek ve sınıfınızı özellikler ve yöntemlerle donatacaksınız.

Nesneler, özellikler ve yöntemler gibi terimlerle ilgili arka plan bilgisi için Temel Konulara Dönüş: PowerShell Nesnelerini Anlamak blog gönderisine göz atın.

Önkoşullar

Birinci Sınıfınızı ve Nesnenizi Oluşturma

PowerShell sınıfının tüm ayrıntılarını öğrenmeden önce basit bir sınıf oluşturma adımlarını izlemelisiniz. Daha ileri konuları daha sonra öğreneceksiniz.

Birinci sınıfınızı oluşturmak biraz fonksiyon oluşturmaya benzeyecektir. Temel sözdizimi aynıdır. Bir sınıf, fonksiyon gibi bir tanımdan yaratılır. Ancak işlevlerden farklı olarak, ilk satır function ve ardından işlevin adı ile başlamaz, class ile başlar ve ardından nesne türünüzün adı gelir.

Aşağıda öğrenci adlı bir sınıfın çıplak iskeletini göreceksiniz.

class student {

}

Sınıflar, o sınıfı tanımlayan nitelikler olan parametrelere benzeyen özelliklere sahiptir. Aşağıdaki örnekte iki özelliğe sahip öğrenci adlı bir sınıf gösterilmektedir; FirstName ve LastName.

Bir özelliği tanımladığınızda, her zaman hangi özellik değerlerinin tutabileceğine ilişkin belirli bir "şema" belirleyen bir tür tanımlamanız gerekir. Aşağıdaki örnekte her iki özellik de dizeler olarak tanımlanmıştır.

Özellik türlerini her zaman tanımlamanız gerekir. Nedenini daha sonra göreceksiniz.

class student {
    [string]$FirstName
    [string]$LastName
}

Bir sınıfı tanımladıktan sonra ondan bir nesne oluşturun veya bir nesnenin örneğini oluşturun. Sınıflardan nesneleri başlatmanın birden çok yolu vardır; Yaygın yollardan biri, sınıfı temsil eden [öğrenci] gibi tür hızlandırıcıları kullanmak ve ardından her sınıfla birlikte gelen new()< adlı varsayılan yöntemi kullanmaktır. /kod>.

Type hızlandırıcı kısayolunu kullanmak, Yeni-Nesne komutunu kullanarak bir nesne oluşturmakla aynıdır.

New-Object -TypeName student

Bu sınıftan bir nesne oluşturduktan sonra özelliklere değerler atayın. Aşağıdaki örnekte FirstName ve LastName özelliklerine Tyler ve Muir değerleri atanmaktadır.

class student {
    [string]$FirstName
    [string]$LastName
}
$student1 = [student]::new()
$student1.FirstName = 'Tyler'
$student1.LastName = 'Muir'
$student1

Nesneyi oluşturduktan ve özelliklere değerler atadıktan sonra, aşağıda gösterildiği gibi nesneyi atadığınız değişkeni çağırarak nesneyi inceleyin.

Artık bir sınıftan bir nesne oluşturduğunuza göre, bu nesneyi PowerShell'deki diğer nesneler gibi incelemek için Get-Member cmdlet'ine yönlendirin. Aşağıda $student1 değişkeninde tutulan nesnenin student türünde olduğunu görebilirsiniz.

Sınıf adı her zaman nesne türüyle ilişkili olacaktır.

Get-Member'ın dört yöntem ve iki özellik döndürdüğüne dikkat edin. Özellikler muhtemelen tanıdık gelebilir ancak yöntemler kesinlikle tanıdık gelmiyor. PowerShell belirli yöntemleri varsayılan olarak ekler, ancak kendi yöntemlerinizi ekleyebilir, hatta varsayılan yöntemleri değiştirebilirsiniz.

Yöntem Oluşturma

Yukarıdaki örnekte, nesnede birkaç varsayılan yöntem gördünüz, ancak muhtemelen kendinizinkini oluşturmak isteyeceksiniz. Bunu yapmak için sınıf tanımının içinde bir veya daha fazla yöntem tanımlamanız gerekir.

Bu yöntemden döndürülen nesne türünü, yöntemin adını ve scriptblock içinde çalıştırılacak kodu tanımlayan bir çıktı türü içeren bir yöntem tanımı aşağıdakine benzer.

[<output type>]<name>() {
	<code that runs when the method is executed>
}

Adın ardından () parantezlerine dikkat edin. Yöntem parametrelerini tanımlayabileceğiniz yer burasıdır (daha sonra ele alınacaktır). Yöntem parametreleri, tıpkı işlev parametrelerinde olduğu gibi, bir yöntemin işlevselliğini değiştirmenize olanak tanır.

Daha önce PowerShell işlevlerini yazıp çalıştırdıysanız, yöntem komut dosyası blokları size tanıdık gelecektir, ancak yöntemler için bilmeniz gereken birkaç özel kural vardır.

return Zorunludur

PowerShell işlevleri, aşağıdaki örnekte olduğu gibi nesneyi işlevin herhangi bir yerine yerleştirerek nesneleri döndürecektir.

function foo {
	$object = Get-Service
	$object ## Just sending the object to the pipeline
}

Ancak işlevlerden farklı olarak, eğer bir yöntem bir nesneyi döndürürse, aşağıda gösterildiği gibi return yapısını kullanmanız gerekir.

[string]GetName() {
	return 'foo'
}

$this Değişkenini Kullanma

Yöntemlerin işlevlerden bir diğer farkı da $this değişkenidir. Bir yöntemin içinde tanımlandığı şekliyle $this değişkeni, geçerli nesnenin özelliklerine veya diğer yöntemlere referans verir.

Aşağıda, FirstName ve LastName< değerini birleştiren student sınıfına eklenen GetName() adı verilen bir yöntem örneği verilmiştir. /code> özellikleri ve bunları döndürür.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
}

Artık aşağıda gösterildiği gibi nokta gösterimini kullanarak GetName() yöntemini çağırabilirsiniz. Daha önce FirstName ve LastName'e değerler atadıysanız, GetName() bunları döndürecektir.

Yöntemlere Parametreler Ekleme

Yukarıdaki örnekte, $student1.GetName() satırını çalıştırdığınızda GetName() yöntemini olduğu gibi çağırıyordunuz. Parantezlerin içinde tıpkı işlevler gibi parametreleri tanımlayabilirsiniz.

GetName() yöntemi, FirstName ve LastName özellikleri için ayarlanmış olan değerleri döndürdü. Peki ya GetName() uygulamasının alabileceği özellikleri ayarlamak için bir yönteme sahip olmayı tercih ederseniz? Bu durumda yöntem parametrelerini tanımlamanız gerekir.

Aşağıda gösterildiği gibi, yöntem parametresi parantezlerine virgülle ayrılmış bir veya daha fazla parametre ekleyerek yöntem parametrelerini tanımlayın.

[void] çıktı türünü not edin. Bir yöntem herhangi bir çıktı vermediğinde, return yapısına ihtiyacınız yoktur ve PowerShell'e yöntemin hiçbir şey döndürmediğini bildirmek için çıktı türünü [void] olarak tanımlamanız gerekir. .

[void]SetName([string]$Name) {

}

Örneğin, SetName() yöntemi tam adı (ad ve soyadı) kabul edebilir. Öyleyse, komut dosyası bloğunda bu dizeyi bölebilir ve adı ve soyadını bu şekilde atayabilirsiniz.

Student sınıfına SetName() yöntemini ekleyerek, şu anki hali aşağıdadır.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Artık geçerli nesnenin FirstName ve LastName özelliklerini ayarlayan SetName() yöntemine parametre olarak tam adı iletebilirsiniz.

Aşırı Yükleme Yöntemleri

Belki bir yöntem için farklı parametre kümeleri tanımlamak isteyebilirsiniz. İşlevlerde ve cmdlet'lerde parametre kümelerinin nasıl çalıştığına benzer şekilde, farklı parametre "bağlamları" veya yöntem imzaları tanımlayabilirsiniz.

Belki FirstName ve LastName parametrelerini, SetName() yöntemine tam adı ileterek veya ilk ve sonuncuyu ileterek ayarlamak isteyebilirsiniz. ayrı ayrı isimlendirin. Seçim yapmak zorunda değilsiniz; ikisini de yöntem imzalarıyla tanımlayabilirsiniz.

Bir sınıfta birden fazla yöntem imzası tanımladığınızda buna aşırı yükleme denir.

Önceki bölümdeki örneği tekrar kullanarak, SetName() yöntemi için bir yerine iki dizeyi kabul edecek bir aşırı yükleme oluşturabilirsiniz. Bir yerine iki dize ilettiğinizde SetName() yöntemi, ilk dizenin FirstName ve ikinci dizenin LastName olduğunu varsayar. . Bu aşırı yük ile sınıf aşağıdaki gibi görünecektir.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
    
    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Sınıf Oluşturucuları

new() yöntemiyle veya başka bir yolla bir nesnenin örneğini oluşturduğunuzda, PowerShell'e yapıcı adı verilen kullanıcı tanımlı bazı kodları çalıştırmasını söyleyebilirsiniz. Yapıcılar yöntemlere benzer ancak PowerShell bir nesneyi başlattığında otomatik olarak çalıştırılırlar.

Her sınıfın varsayılan bir yapıcısı vardır. Bu varsayılan kurucu pek bir şey yapmaz; o sadece nesneyi somutlaştırmaktan sorumludur. New yönteminin çıktısını görüntüleyerek varsayılan kurucuyu görebilirsiniz. Aşağıda bu satırın tek bir new() yöntemi döndürdüğünü görebilirsiniz.

[student]::New

Yapıcının Aşırı Yüklenmesi

Belki de nesneyi oluşturur oluşturmaz FirstName ve LastName özellikleri için tipik nokta gösterimiyle değil, bir değer ayarlamak isteyebilirsiniz. Bu durumda, SetName()'ı çağıran bir parametreye sahip bir kurucu oluşturabilirsiniz.

Aşağıda student sınıfı için bir kurucu örneği verilmiştir. Yapıcının belirli bir adı olmadığına veya başında bir çıktı türü olduğuna dikkat edin. Yapıcılar her zaman sınıfla aynı adı kullanır.

Yapıcıda mevcut bir yöntemi çağırmak, değişkenleri ayarlamak için önceden yazdığımız yöntemi yeniden kullanmamıza olanak tanır.

student([string]$Name) {
	$this.SetName($Name)
}

Aşağıda bu kurucunun student sınıfına eklendiğini göreceksiniz.

class student {
    [string]$FirstName
    [string]$LastName
    
    student([string]$Name) {
        $this.SetName($Name)
    }

    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Yeni bir student nesnesi başlattığınızda ve bir dize parametresi ilettiğinizde, nesne özellikleri hemen beklenen değerlere sahip olacaktır.

Artık aşırı yüklenmiş kurucuyu [student]::New ile tekrar görebilirsiniz. Şimdi yeni aşırı yüklenmiş kurucunun bir Ad parametresiyle tanımlandığına dikkat edin.

Varsayılan ve Aşırı Yüklenmiş Bir Yapıcı Tanımlama

Artık student sınıfınızda aşırı yüklenmiş bir kurucunuz olduğuna göre, PowerShell varsayılan kurucunun üzerine yazar. Ancak, parametreleri olmadan manuel olarak bir tane oluşturarak onu geri alabilirsiniz.

student() {}

Aşağıdaki öğrenci sınıfında bunun neye benzediğini görebilirsiniz.

class student {
    [string]$FirstName
    [string]$LastName

    student([string]$Name) {
        $this.SetName($Name)
    }

    student() {}

    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Şimdi yapıcıları tekrar kontrol edin. Artık her iki kurucunun da ortaya çıktığını göreceksiniz.

[student]::New

Sınıf Mirası

Diğer tüm nesne yönelimli diller gibi, PowerShell sınıflarını da birden çok sınıfla hiyerarşik olarak oluşturabilirsiniz. Her sınıfta daha az spesifik, daha genel amaçlardan başlayan ve özgüllüğü artıran “ebeveyn” ve “çocuk” sınıfları bulunabilir.

Örneğin, student sınıfımız bir üniversite öğrencisini (çocuk/özel) temsil eder. O üniversite öğrencisi bir kişidir (ebeveyn/jenerik). Bu iki kavram birbiriyle ilişkilidir ve bir hiyerarşi oluşturur.

Bir alt sınıf, bir üst sınıfı devralabilir; bu, bir üst sınıf aracılığıyla tanımlanan tüm özellikleri ve yöntemleri (üyeleri) tutabileceği anlamına gelir. Bir kişi sınıfının eye_color, height ve weight gibi özelliklere ve belki de < adında bir yönteme sahip olabileceğini biliyoruz.SetHeight().

Eğer öğrenci bir kişi ise, o öğrenci yine o özelliklere ve yöntemlere sahiptir. person sınıfının zaten sahip olduğu aynı üyeleri student sınıfına da uygulama çabası iki katına çıkar. student sınıfındaki kişi sınıfının tüm üyelerini otomatik olarak tanımlamak için sınıf mirasını tanımlayabilirsiniz.

Eğer bu şimdi bir anlam ifade etmiyorsa, demoyu incelerken anlamlı olacaktır.

Sınıf Mirası Demosu

Öncelikle, daha önce oluşturduğunuz student sınıfının bir kopyasını oluşturun, yapıcıları kaldırın ve onu bir person sınıfı olarak yeniden adlandırın. kişi sınıfınız aşağıdaki sınıfı beğenmelidir.

Bir öğrencinin elbette bir adı ve soyadı vardır, ancak sınıf, onu bir kişi olarak etiketleyerek daha doğru bir şekilde tanımlanabilir. Bunun gibi daha "genel" bir sınıf oluştururken, ondan daha spesifik "alt" sınıflar oluşturabilirsiniz.

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Şimdi, bir kişiyi temsil eden ancak daha spesifik bir role sahip birkaç sınıf oluşturun. Örneğin, aşağıdaki kod parçacığında artık bir öğretmen ve öğrenci sınıfınız var.

class teacher {
    [int]$EmployeeId
}

class student {
    [int]$StudentId
}

Olduğu gibi, öğretmen ve öğrenci sınıfı, kişi sınıfından birbirini dışlar. Hiçbir ilişkileri yoktur ancak person sınıfının herhangi bir sınıf üyesini miras alamazlar. Bunu değiştirelim.

Şimdi öğretmen ve öğrenci sınıfını, kişi sınıfının mirasa sahip “alt” sınıfları olarak tanımlayarak bu hiyerarşiyi tanımlayın. Aşağıda gösterildiği gibi sınıf adından sonra iki nokta üst üste (:) ve ardından üst sınıfın adını ekleyerek kalıtımı tanımlayabilirsiniz.

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

Sınıf betiğinizin tamamı artık şöyle görünmelidir:

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

Bu noktada öğretmen veya öğrenci sınıfından bir nesne başlattığınızda, her iki sınıf da kişi sınıfıyla aynı üyelere sahip olacaktır.

Oluşturuculardan Devralma

Yukarıda gördüğünüz gibi sınıf yöntemleri, sınıf mirası yoluyla miras alınır. Bu davranış, yapıcıların da aynı mantığı izleyeceğini düşünmenize neden olabilir ancak yanılıyorsunuz. Yapıcılar miras alınmaz ve tüm alt sınıfların yapıcıları her alt sınıfta ayrı ayrı tanımlanmalıdır.

Örneğin, aşağıda gösterildiği gibi person sınıfı için aşırı yüklenmiş bir kurucu tanımlamış olabilirsiniz ancak öğretmen sınıfı için bir kurucu tanımlamamış olabilirsiniz.

class person {
    [string]hidden $FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }

		person([string]$Name) {
			$this.SetName($Name)
		}
}

Daha sonra, örneğin öğretmen gibi bir alt sınıf tanımlarsınız ve aşağıda gösterildiği gibi, bu sınıftan hiçbir parametre içermeyen bir nesne oluşturmaya çalışırsınız. öğretmen sınıfı içinde parametresiz bir kurucu tanımlanmadığından PowerShell'in bir hata döndürdüğüne dikkat edin.

Bir alt sınıfta yalnızca şablon olarak kullanıyorsanız kurucuya gerek yoktur. Alternatif olarak, ana sınıfı kendi bağımsız sınıfı olarak ve ana sınıf olarak kullanmak istiyorsanız yapıcıları dahil edebilirsiniz. Ancak ana sınıfın, alt sınıflardakilerle eşleşen bir kurucuya sahip olduğundan emin olmalısınız.

Sınıf Üyesi Nitelikleri

Tıpkı PowerShell komut parametreleri gibi sınıfların da üye özellikleri olabilir. Bu nitelikler her üyenin davranışını değiştirir.

Gizli Üyeler

Bir sınıf üyesini yalnızca dahili amaçlarla kullanıyorsanız ve kullanıcının bu üyeyi okumasını veya yazmasını istemiyorsanız, üyeyi gizli olarak ayarlarsınız. Örneğin, yalnızca diğer yöntemler tarafından kullanılan bir yönteminiz olabilir. Bu yöntemi kullanıcıya göstermeye gerek yoktur.

Gizli üye tanımlamak için aşağıda gösterildiği gibi hidden özelliğini kullanın.

class teacher {
    [int]hidden $EmployeeId
}

Artık tüm nesne üyelerini incelemek için Get-Member'i kullandığınızda bu özellik görünmüyor.

Bir sınıf üyesini gizli olarak ayarlamak, değere erişimi kısıtlamaz; yalnızca onu görünümden gizler. Hassas verileri depolamak için özellikleri gizlememelisiniz.

Statik Üyeler

Daha önce hatırlayın; Bu eğitimde, bir sınıftan nesne oluşturmayı tanımlamak için "örnekleme" terimi kullanıldı. Bir nesneyi başlattığınızda, o nesne sınıfın tanımladığı tüm özellikleri ve yöntemleri alır. Ancak durum her zaman böyle değildir.

Bazen bir nesnenin tamamını somutlaştırma yüküne ihtiyacınız olmaz. Bunun yerine tek bir sınıf üyesine hızlı bir şekilde başvuruda bulunmanız gerekir. Bu durumda bir sınıf üyesini statik olarak ayarlayabilirsiniz.

Tıpkı hidden özelliğinde olduğu gibi, aşağıda gösterildiği gibi static anahtar sözcüğünü kullanarak bir sınıf üyesini statik olarak tanımlayın.

class student {
	[int]static $MaxClassCount = 7
}

Tipik sınıf üyelerinden farklı olarak PowerShell, statik sınıf üyelerinden özellikler ve yöntemler oluşturmaz. Bir sınıf üyesini gizli üyeler gibi statik olarak tanımladığınızda, Get-Member'i kullandığınızda görünmez.

Örneğin, üniversitedeki sınıf adlarını öğrenci sınıfıyla ilişkilendirmek ve bir öğrencinin katılabileceği maksimum üniversite dersi sayısını tanımlamak isteyebilirsiniz. Bunu yapmak için bir Sınıflar oluşturursunuz. dizi üyesi ve bir MaxClassCount üyesi.

Kullanıcının MaxClassCount üyesini nadiren değiştirmesi gerektiğinden, onu statik olarak tanımlamaya karar verirsiniz.

Son olarak, öğrencinin programına bir sınıf eklemek için bir AddClass() yöntemi oluşturursunuz, ancak bu yalnızca bu MaxClassCount değerinden küçükse.

class student {
    [string[]]$Classes = @()
    [int]static $MaxClassCount = 7
    
    [void]AddClass ([string]$Name) {
        if ($this.Classes.Count -lt [student]::MaxClassCount) {
            $this.Classes += $Name
        }
    }
}

Artık yeni bir student nesnesi oluşturup ona çok fazla üniversite dersi atamaya çalıştığınızda, PowerShell yalnızca maksimum sayı olan yediyi atayacaktır.

$student1 = [student]::new()
'PE','English','Math','History','Computer Science','French','Wood Working','Cooking' | ForEach-Object {
	$student1.AddClass($_)
}
$student1.Classes

Statik üye değerlerini istediğiniz zaman değiştirebilirsiniz. Örneğin, MaxClassCount üyesini 7 yerine 5 yapmak istiyorsanız, değeri [student]::MaxClassCount=5 kullanarak değiştirirsiniz. Değerin değiştirilmesi, bu örnekte sınırı aşan sınıfları geriye dönük olarak kaldırmaz.

Sonuç

PowerShell sınıfları, betik dili ile programlama dili arasındaki çizgiyi bulanıklaştırır. Sınıflar, nesne ilişkilerini tanımlamanın, normalde yalnızca özel işlevler yazılarak mümkün olan nesnelerle etkileşim kurmanın ve nesneleri biçimlendirmenin yollarını eklemenin harika bir yoludur.