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 trefwoordClass 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 openbaar binnen het modulebereik.Class members are public, but only public within the module scope. U mag niet verwijzen naar de naam van het als een tekenreeks (bijvoorbeeld New-Object niet werkt), en in deze release kunt u een letterlijke type niet gebruiken (bijvoorbeeld [MyClass]) buiten de 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 het scheidingsteken.Support for the enum keyword has been added, which uses newline as the delimiter. Huidige beperkingen: u kunt een enumerator voor wat betreft zelf niet definiëren, maar kunt u een enum-waarde 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 enumerator voor de waarde moet een constante parseren; u kunt deze niet instellen op het resultaat van een aangeroepen opdracht.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
}

Enum-waarden ondersteunt 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 }

Sleutelwoorden import-dscresource biedenImport-DscResource

Sleutelwoorden import-dscresource bieden is nu een waar dynamische trefwoord.Import-DscResource is now a true dynamic keyword. PowerShell parseert basismodule van de opgegeven module, zoeken naar klassen die bevatten de sleutelwoorden dscresource bieden 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. Deze waarde is ingesteld op de dynamische verzameling voor een scriptmodule gemaakt als het script klassen definieert, of de geladen assembly 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 resources in een module heeft gedetecteerd.Reflection on the ImplementingAssembly field discovers resources in a module. Dit betekent dat u kunt de resources die zijn geschreven in PowerShell of andere beheerde talen detecteren.This means you can discover resources written in either PowerShell or other managed languages.

Velden met initializers:Fields with initializers:

[int] $i = 5

Statische ondersteund. het werkt als een kenmerk, zoals de typebeperkingen, dat wel doet, 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 van de zijn openbaar.All members are public.

Constructors en instantiëringConstructors and instantiation

Windows PowerShell-klassen kunnen constructors; hebben ze hebben dezelfde naam als de klasse.Windows PowerShell classes can have constructors; they have the same name as their class. Constructors kunnen worden overbelast.Constructors can be overloaded. Statische constructors worden ondersteund.Static constructors are supported. Eigenschappen met expressies voor objectinitialisatie geïnitialiseerd voordat u code uitvoert 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 instantie-eigenschappen 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 het aanroepen van een constructor 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 van het 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 dat New-Object niet wordt 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 wordt doorgegeven aan de constructor met meerdere parametersPassing an array to a constructor with multiple parameters

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

In deze release werkt het New-Object niet met 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 lexicaal, wat betekent dat deze zijn niet zichtbaar is 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 kunnen retourneren exemplaren van een klasse is gedefinieerd in Windows PowerShell en exemplaren werken ook 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 -Static Geeft een lijst van 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 is 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 ziet nu de constructor overloads met Get-Member, of als 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

Een Windows PowerShell-methode de klasse wordt geïmplementeerd als een ScriptBlock waarvoor 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. De volgende toont 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) {}
}

Aanroepen van de methode:Method invocation:

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

Overbelaste methoden, dat wil zeggen, die met de naam van een bestaande methode, 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 van vereist een nieuwe regel of door puntkomma's.Properties require either a newline or semicolon. Als er geen objecttype is opgegeven, is het type object.If no object type is specified, the property type is object.

Eigenschappen die gebruikmaken van validatie kenmerken of argument transformatie kenmerken (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 sleutelwoord, verborgen, is toegevoegd.A new keyword, Hidden, has been added. Verborgen kan worden toegepast op eigenschappen en methoden (met inbegrip van constructors).Hidden can be applied to properties and methods (including constructors).

Verborgen leden openbaar zijn, maar worden niet weergegeven in de uitvoer van Get-Member, tenzij de - Force parameter is 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 vindt plaats 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 semantiek 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.

Typen retournerenReturn types

Retourtype is een overeenkomst; de geretourneerde waarde 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 is ongeldig.If no return type is specified, the return type is void. Er is geen streaming met 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, sleutelwoorden dscresource bieden en DscProperty zijn toegevoegd.Two new attributes, DscResource and DscProperty have been added.

Lexicale bereik van variabelenLexical scoping of variables

Hieronder ziet u een voorbeeld van hoe lexicale scoping 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

Voorbeeld van de end-to-EndEnd-to-End Example

Het volgende voorbeeld wordt de 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 ondersteunende functies voor het maken van specifieke elementtypen als onderdeel van de elementklasse, zoals opmaakprofielen 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 }