Nieuwe taalfuncties in PowerShell 5.0New language features in PowerShell 5.0

PowerShell 5.0 introduceert de volgende nieuwe taalelementen in Windows PowerShell:PowerShell 5.0 introduces the following new language elements in Windows PowerShell:

Klasse sleutelwoordClass keyword

De klasse sleutelwoord definieert een nieuwe klasse.The class keyword defines a new class. Dit is een echte .NET Framework-type.This is a true .NET Framework type. Klasseleden zijn openbaar, maar alleen openbare binnen het modulebereik.Class members are public, but only public within the module scope. U mag niet verwijzen naar de typenaam als tekenreeks (bijvoorbeeld New-Object niet werkt), en in deze release kunt u een letterlijke waarde van het type niet gebruiken (bijvoorbeeld [MyClass]) buiten het scriptmodule /-bestand waarin de klasse is gedefinieerd.You can't refer to the type name as a string (for example, New-Object doesn't work), and in this release, you can't use a type literal (for example, [MyClass]) outside the script/module file in which the class is defined.

class MyClass
{
    ...
}

Enum-sleutelwoord en opsommingenEnum keyword and enumerations

Ondersteuning voor de enum sleutelwoord is toegevoegd, waarbij nieuwe regel wordt gebruikt als scheidingsteken.Support for the enum keyword has been added, which uses newline as the delimiter. Huidige beperkingen: u kunt een enumerator in termen van zelf niet definiëren, maar u kunt een enum in termen van een andere enum initialiseren, zoals wordt weergegeven in het volgende voorbeeld.Current limitations: you cannot define an enumerator in terms of itself, but you can initialize an enum in terms of another enum, as shown in the following example. Het basistype kan niet ook op dat moment worden opgegeven; het is altijd [int].Also, the base type cannot currently be specified; it is always [int].

enum Color2
{
    Yellow = [Color]::Blue
}

Een enumeratorwaarde moet een constante parse; u kunt deze niet instellen op het resultaat van een opdracht aangeroepen.An enumerator value must be a parse time constant; you cannot set it to the result of an invoked command.

enum MyEnum
{
    Enum1
    Enum2
    Enum3 = 42
    Enum4 = [int]::MaxValue
}

Enums ondersteuning voor rekenkundige bewerkingen, zoals wordt weergegeven in het volgende voorbeeld.Enums support arithmetic operations, as shown in the following example.

enum SomeEnum { Max = 42 }
enum OtherEnum { Max = [SomeEnum]::Max + 1 }

Importeren DscResourceImport-DscResource

Importeren DscResource is nu een waar dynamische sleutelwoord.Import-DscResource is now a true dynamic keyword. PowerShell parseert de opgegeven module root-module, zoeken naar klassen die bevatten de DscResource kenmerk.PowerShell parses the specified module’s root module, searching for classes that contain the DscResource attribute.

ImplementingAssemblyImplementingAssembly

Een nieuw veld ImplementingAssembly, is toegevoegd aan ModuleInfo.A new field, ImplementingAssembly, has been added to ModuleInfo. Het is ingesteld op de dynamische assembly voor een scriptmodule gemaakt als het script klassen gedefinieerd of de assembly geladen voor binaire modules.It is set to the dynamic assembly created for a script module if the script defines classes, or the loaded assembly for binary modules. Het is niet ingesteld als ModuleType = Manifest.It is not set when ModuleType = Manifest.

Na te denken over de ImplementingAssembly veld detecteert resources in een module.Reflection on the ImplementingAssembly field discovers resources in a module. Dit betekent dat u de resources die zijn geschreven in PowerShell of andere beheerde talen kunt detecteren.This means you can discover resources written in either PowerShell or other managed languages.

De velden met initalisatiefuncties:Fields with initializers:

[int] $i = 5

Statische ondersteund. Dit werkt als een kenmerk, evenals de typebeperkingen, zodat deze kan worden opgegeven in een willekeurige volgorde.Static is supported; it works like an attribute, as do the type constraints, so it can be specified in any order.

static [int] $count = 0

Een type is optioneel.A type is optional.

$s = "hello"

Alle leden zijn openbaar.All members are public.

Constructors en instantiëringConstructors and instantiation

Windows PowerShell-klassen kunnen hebben constructors; ze hebben dezelfde naam als de klasse.Windows PowerShell classes can have constructors; they have the same name as their class. Constructors kunnen overbelast.Constructors can be overloaded. Statische constructors worden ondersteund.Static constructors are supported. Eigenschappen met initialisatie-expressies zijn geïnitialiseerd voordat code wordt uitgevoerd in een constructor.Properties with initialization expressions are initialized before running any code in a constructor. Statische eigenschappen worden geïnitialiseerd voordat de hoofdtekst van een statische constructor en eigenschappen van objectexemplaar zijn geïnitialiseerd voordat de hoofdtekst van de niet-statische constructor.Static properties are initialized before the body of a static constructor, and instance properties are initialized before the body of the non-static constructor. Er is momenteel geen syntaxis voor een constructor aanroept vanuit een andere constructor (zoals de C# syntaxis ': this()").Currently, there is no syntax for calling a constructor from another constructor (like the C# syntax ": this()"). De tijdelijke oplossing is voor het definiëren van een algemene Init-methode.The workaround is to define a common Init method.

De volgende zijn manieren instantiëren van klassen in deze release.The following are ways of instantiating classes in this release.

Instantiëren met behulp van de standaardconstructor.Instantiating by using the default constructor. Houd er rekening mee New-Object wordt niet ondersteund in deze release.Note that New-Object is not supported in this release.

$a = [MyClass]::new()

Aanroepen van een constructor met een parameterCalling a constructor with a parameter

$b = [MyClass]::new(42)

Een matrix doorgeven aan een constructor met meerdere parametersPassing an array to a constructor with multiple parameters

$c = [MyClass]::new(@(42,43,44), "Hello")

In deze release werkt New-Object niet met de klassen die zijn gedefinieerd in Windows PowerShell.In this release, New-Object does not work with classes defined in Windows PowerShell. Ook voor deze release is de typenaam alleen zichtbaar lexically, wat betekent dat het is niet zichtbaar zijn buiten de module of het script dat de klasse definieert.Also for this release, the type name is only visible lexically, meaning it is not visible outside of the module or script that defines the class. Functies exemplaren van een klasse is gedefinieerd in Windows PowerShell kunnen terugkeren en exemplaren werken goed buiten de module of het script.Functions can return instances of a class defined in Windows PowerShell, and instances work well outside of the module or script.

Get-Member -StaticGeeft een lijst constructors, zodat u overloads zoals een andere methode kunt bekijken.Get-Member -Static lists constructors, so you can view overloads like any other method. De prestaties van deze syntaxis werkt ook aanzienlijk sneller dan New-Object.The performance of this syntax is also considerably faster than New-Object.

De pseudo statische methode met de naam nieuwe werkt met .NET-typen, zoals wordt weergegeven in het volgende voorbeeld.The pseudo-static method named new works with .NET types, as shown in the following example.

[hashtable]::new()

U kunt nu zien constructor overloads met Get-lid of zoals in dit voorbeeld wordt weergegeven:You can now see constructor overloads with Get-Member, or as shown in this example:

PS> [hashtable]::new
OverloadDefinitions
-------------------
hashtable new()
hashtable new(int capacity)
hashtable new(int capacity, float loadFactor)

MethodenMethods

De methode van een Windows PowerShell-klasse wordt geïmplementeerd als een ScriptBlock met alleen een end-blok.A Windows PowerShell class method is implemented as a ScriptBlock that has only an end block. Alle methoden zijn openbaar.All methods are public. Hieronder vindt u een voorbeeld van het definiëren van een methode met de naam DoeIets.The following shows an example of defining a method named DoSomething.

class MyClass
{
    DoSomething($x)
    {
        $this._doSomething($x) # method syntax
    }
    private _doSomething($a) {}
}

De methodeaanroep:Method invocation:

$b = [MyClass]::new()
$b.DoSomething(42) 

Overbelaste methoden--dat wil zeggen, die hetzelfde zijn als een bestaande methode met de naam, maar met de opgegeven waarden--onderscheiden worden ook ondersteund.Overloaded methods--that is, those that are named the same as an existing method, but differentiated by their specified values--are also supported.

EigenschappenProperties

Alle eigenschappen zijn openbaar.All properties are public. Eigenschappen vereisen een nieuwe regel of een puntkomma.Properties require either a newline or semicolon. Als er geen objecttype is opgegeven, is het eigenschapstype-object.If no object type is specified, the property type is object.

Eigenschappen die validatie kenmerken of argument transformatie kenmerken worden gebruikt (bijvoorbeeld [ValidateSet("aaa")]) werkt zoals verwacht.Properties that use validation attributes or argument transformation attributes (e.g. [ValidateSet("aaa")]) work as expected.

VerborgenHidden

Een nieuw trefwoord Hidden, is toegevoegd.A new keyword, Hidden, has been added. Verborgen kunnen worden toegepast op eigenschappen en methoden (inclusief constructors).Hidden can be applied to properties and methods (including constructors).

Verborgen leden zijn openbaar, maar worden niet weergegeven in de uitvoer van Get-lid, tenzij de - Force parameter wordt toegevoegd.Hidden members are public, but do not appear in the output of Get-Member unless the -Force parameter is added.

Verborgen leden zijn niet opgenomen wanneer tabblad voltooien of met behulp van Intellisense tenzij de voltooiing van deze gebeurtenis treedt op in de klasse voor het definiëren van het verborgen lid.Hidden members are not included when tab completing or using Intellisense unless the completion occurs in the class defining the hidden member.

Een nieuw kenmerk System.Management.Automation.HiddenAttribute is toegevoegd zodat C#-code dezelfde betekenis in Windows PowerShell hebben kunt.A new attribute, System.Management.Automation.HiddenAttribute has been added so that C# code can have the same semantics within Windows PowerShell.

RetourtypenReturn types

Retourtype is een contract; de retourwaarde wordt geconverteerd naar het verwachte type.Return type is a contract; the return value is converted to the expected type. Als er geen retourtype is opgegeven, is het retourtype void.If no return type is specified, the return type is void. Er is geen streaming-objecten. objecten kunnen niet worden geschreven naar de pijplijn opzettelijk of per ongeluk.There is no streaming of objects; objects cannot be written to the pipeline either intentionally or by accident.

KenmerkenAttributes

Twee nieuwe kenmerken DscResource en DscProperty zijn toegevoegd.Two new attributes, DscResource and DscProperty have been added.

Lexicale bereik van variabelenLexical scoping of variables

De volgende toont een voorbeeld van hoe lexicale bereik werken in deze release.The following shows an example of how lexical scoping works in this release.

$d = 42 # Script scope

function bar
{
    $d = 0 # Function scope
    [MyClass]::DoSomething()
}

class MyClass
{
    static [object] DoSomething()
    {
        return $d # error, not found dynamically
        return $script:d # no error
        $d = $script:d
        return $d # no error, found lexically
    }
}

$v = bar
$v -eq $d # true

End-to-End-voorbeeldEnd-to-End Example

Het volgende voorbeeld maakt diverse nieuwe, aangepaste klassen voor het implementeren van een HTML-dynamische taal van het opmaakmodel (DSL).The following example creates several new, custom classes to implement an HTML dynamic style sheet language (DSL). Het voorbeeld wordt vervolgens hulpfuncties voor het maken van specifieke elementtypen als onderdeel van de elementklasse zoals kopstijlen en tabellen, omdat de typen kunnen niet worden gebruikt buiten het bereik van een module.Then, the example adds helper functions to create specific element types as part of the element class, such as heading styles and tables, because types cannot be used outside the scope of a module.

# Classes that define the structure of the document
#
class Html
{
    [string] $docType
    [HtmlHead] $Head
    [Element[]] $Body

    [string] Render()
    {
        $text = "<html>`n<head>`n"
        $text += $this.Head
        $text += "`n</head>`n<body>`n"
        $text += $this.Body -join "`n" # Render all of the body elements
        $text += "</body>`n</html>"
        return $text
    }
    [string] ToString() { return $this.Render() }
}

class HtmlHead
{
    $Title
    $Base
    $Link
    $Style
    $Meta
    $Script
    [string] Render() { return "<title>$($this.Title)</title>" }
    [string] ToString() { return $this.Render() }
}

class Element
{
    [string] $Tag
    [string] $Text
    [hashtable] $Attributes
    [string] Render() {
        $attributesText= ""
        if ($this.Attributes)
        {
            foreach ($attr in $this.Attributes.Keys)
            {
                #BUGBUG - need to validate keys against attribute
                $attributesText += " $attr=`"$($this.Attributes[$attr])\`""
            }
        }
        return "<$($this.tag)${attributesText}>$($this.text)</$($this.tag)>`n"
    }
[string] ToString() { return $this.Render() }
}

#
# Helper functions for creating specific element types on top of the classes.
# These are required because types aren’t visible outside of the module.
#

function H1 { [Element] @{ Tag = "H1" ; Text = $args.foreach{$_} -join " " }}
function H2 { [Element] @{ Tag = "H2" ; Text = $args.foreach{$_} -join " " }}
function H3 { [Element] @{ Tag = "H3" ; Text = $args.foreach{$_} -join " " }}
function P { [Element] @{ Tag = "P" ; Text = $args.foreach{$_} -join " " }}
function B { [Element] @{ Tag = "B" ; Text = $args.foreach{$_} -join " " }}
function I { [Element] @{ Tag = "I" ; Text = $args.foreach{$_} -join " " }}
function HREF
{
    param (
        $Name,
        $Link
    )
    return [Element] @{
        Tag = "A"
        Attributes = @{ HREF = $link }
        Text = $name
    }
}
function Table
{
    param (
    [Parameter(Mandatory)]
    [object[]]
        $Data,
    [Parameter()]
    [string[]]
        $Properties = "*",
    [Parameter()]
    [hashtable]
        $Attributes = @{ border=2; cellpadding=2; cellspacing=2 }
    )
$bodyText = ""
# Add the header tags
$bodyText += $Properties.foreach{TH $_}
# Add the rows
$bodyText += foreach ($row in $Data)
    {
        TR (-join $Properties.Foreach{ TD ($row.$\_) } )
    }

    $table = [Element] @{
        Tag = "Table"
        Attributes = $Attributes
        Text = $bodyText
    }
$table
}
function TH { ([Element] @{ Tag = "TH" ; Text = $args.foreach{$_} -join " " }) }
function TR { ([Element] @{ Tag = "TR" ; Text = $args.foreach{$_} -join " " }) }
function TD { ([Element] @{ Tag = "TD" ; Text = $args.foreach{$_} -join " " }) }
function Style

{
    return [Element] @{
        Tag = "style"
        Text = "$args"
    }
}

# Takes a hash table, casts it to and HTML document
# and then returns the resulting type.
#
function Html ([HTML] $doc) { return $doc }