登录  |  注册
当前位置：网站首页 > 更多 > 玩电脑 > 正文

[玩转系统] 关于枚举

作者：精品下载站 日期：2024-12-14 02:23:19 浏览：14 分类：玩电脑

关于枚举

简短描述

enum 语句声明一个枚举。枚举是一种独特的类型，由一组称为枚举器列表的命名标签组成。

详细描述

enum 语句允许您创建一组强类型标签。您可以在代码中使用该枚举，而无需解析或检查拼写错误。

枚举在内部表示为起始值为零的整数值类型。默认情况下，PowerShell 枚举使用 System.Int32 ([int]) 作为基础类型。默认情况下，PowerShell 为列表中的第一个标签分配值零。默认情况下，PowerShell 为其余标签分配连续整数。

在定义中，您可以为标签指定任何整数值。未分配值的标签采用下一个整数值。

句法

枚举使用以下语法：

整数枚举定义语法

[[<attribute>]...] enum <enum-name> {
    <label> [= <int-value>]
    ...
}

具体的底层类型枚举定义语法

[[<attribute>]...] enum <enum-name> : <underlying-type-name> {
    <label> [= <int-value>]
    ...
}

标志枚举定义语法

[[<attribute>]...] [Flag()] enum <enum-name>[ : <underlying-type-name>] {
    <label 0> [= 1]
    <label 1> [= 2]
    <label 2> [= 4]
    <label 3> [= 8]
    ...
    ...
}

枚举访问语法

[<enum-name>]::<label>

示例

示例 1 - 最小枚举

以下代码块定义了具有三个标签的 MarkdownUnorderedListCharacter 枚举。它不会为任何标签分配明确的值。

enum MarkdownUnorderedListCharacter {
    Asterisk
    Dash
    Plus
}

下一个代码块显示了整数和字符串值在转换为枚举类型时的行为方式。

$ValuesToConvert = @(0, 'Asterisk', 1, 'Dash', 2, 'Plus')
foreach ($Value in $ValuesToConvert) {
    [MarkdownUnorderedListCharacter]$EnumValue = $Value

    [pscustomobject]@{
        AssignedValue = $Value
        Enumeration   = $EnumValue
        AreEqual      = $Value -eq $EnumValue
    }
}

AssignedValue Enumeration AreEqual
------------- ----------- --------
            0    Asterisk     True
     Asterisk    Asterisk     True
            1        Dash     True
         Dash        Dash     True
            2        Plus     True
         Plus        Plus     True

转换等于枚举值的整数会返回该枚举。转换与枚举标签相同的字符串会返回该枚举。

示例 2 - 显式和同义词枚举值

以下示例显示与媒体文件相关的对象的枚举。该定义将显式值分配给 music、picture、video 的基础值。紧随显式赋值之后的标签将获取下一个整数值。您可以通过将相同的值分配给另一个标签来创建同义词；查看以下构造的值：ogg、oga、mogg 或 jpg、jpeg，或mpg、mpeg。

enum MediaTypes {
    unknown
    music   = 10
    mp3
    aac
    ogg     = 15
    oga     = 15
    mogg    = 15
    picture = 20
    jpg
    jpeg    = 21
    png
    video   = 40
    mpg
    mpeg    = 41
    avi
    m4v
}

GetEnumNames() 方法返回枚举的标签列表。

[MediaTypes].GetEnumNames()

unknown
music
mp3
aac
ogg
oga
mogg
picture
jpg
jpeg
png
video
mpg
mpeg
avi
m4v

GetEnumValues() 方法返回枚举值的列表。

[MediaTypes].GetEnumValues()

unknown
music
mp3
aac
ogg
ogg
ogg
picture
jpg
jpg
png
video
mpg
mpg
avi
m4v

笔记

GetEnumNames() 和 GetEnumValues() 似乎返回相同的结果；命名值的列表。但是，在内部，GetEnumValues() 枚举值，然后将值映射到名称。仔细阅读该列表，您会注意到 ogg、oga 和 mogg 出现在 GetEnumNames() 的输出中，但 GetEnumValues() 的输出仅显示 ogg。对于 jpg、jpeg 和 mpg、mpeg 也会发生同样的情况。 PowerShell 为同义词值返回的名称不是确定性的。

您可以使用 GetEnumName() 方法获取与特定值关联的名称。如果有多个名称与一个值关联，则该方法返回第一个定义的名称。

[MediaTypes].GetEnumName(15)

ogg

以下示例演示如何将每个名称映射到其值。

[MediaTypes].GetEnumNames() | ForEach-Object {
  [pscustomobject]@{
    Name = $_
    Value = [int]([MediaTypes]::$_)
  }
}

Name    Value
----    -----
unknown     0
music      10
mp3        11
aac        12
ogg        15
oga        15
mogg       15
picture    20
jpg        21
jpeg       21
png        22
video      40
mpg        41
mpeg       41
avi        42
m4v        43

您可以使用语法 []:: Enum 的枚举，如 byteEnum。定义的枚举使用指定的整型类型作为基础值类型。

枚举是通过将 Min 值设置为整数类型的最小值来定义的。它将 Max 值定义为整数类型的最大值。

  • 返回新定义的类型。

    • $DefinitionTemplate = @"
enum {0}Enum : {0} {{
    Min = [{0}]::MinValue
    Max = [{0}]::MaxValue
}}

[{0}Enum]
"@

    下一个代码块使用模板在当前范围内创建并调用脚本块。它将返回的类型定义添加到 $EnumTypes 数组中。

    foreach ($IntegralType in $IntegralTypes) {
    $Definition  = $DefinitionTemplate -f $IntegralType
    $ScriptBlock = [scriptblock]::Create($Definition)
    $EnumTypes  += . $ScriptBlock
}

    最后一个代码块循环遍历枚举类型，使用 GetEnumValuesAsUnderlyingType() 方法将值列出为基础类型。该循环为每个值创建一个新对象，显示枚举类型、值类型、标签和实际值。

    foreach ($EnumType in $EnumTypes) {
    $EnumType.GetEnumValuesAsUnderlyingType() | ForEach-Object {
        [pscustomobject]@{
            EnumType  = $EnumType.FullName
            ValueType = $_.GetType().FullName
            Label     = $EnumType.GetEnumName($_)
            Value     = $_
        }
    }
}

    EnumType   ValueType     Label                Value
--------   ---------     -----                -----
byteEnum   System.Byte   Min                      0
byteEnum   System.Byte   Max                    255
sbyteEnum  System.SByte  Max                    127
sbyteEnum  System.SByte  Min                   -128
shortEnum  System.Int16  Max                  32767
shortEnum  System.Int16  Min                 -32768
ushortEnum System.UInt16 Min                      0
ushortEnum System.UInt16 Max                  65535
intEnum    System.Int32  Max             2147483647
intEnum    System.Int32  Min            -2147483648
uintEnum   System.UInt32 Min                      0
uintEnum   System.UInt32 Max             4294967295
longEnum   System.Int64  Max    9223372036854775807
longEnum   System.Int64  Min   -9223372036854775808
ulongEnum  System.UInt64 Min                      0
ulongEnum  System.UInt64 Max   18446744073709551615

    枚举方法

    以下列表包括可用于 PowerShell 中枚举的有用方法以及如何使用它们。

    格式

    Format() 静态方法返回给定枚举类型、枚举值和格式字符串的格式化字符串输出。输出与对具有指定格式字符串的值调用 ToString 方法相同。

    您可以在System.Enum基类类型或特定枚举类型上使用静态方法。

    [System.Enum]::format([<enum-name>], <value>, <format-string>)

    [<enum-name>]::format([<enum-name>], <value>, <format-string>)

    有效的格式字符串为 G 或 g、D 或 d、X 或x 和 F 或 f。有关详细信息，请参阅枚举格式字符串。

    以下示例使用每个受支持的枚举格式字符串将 TaskState 枚举的每个值转换为其字符串表示形式。

    enum TaskState {
    ToDo
    Doing
    Done
}

# String format template for the statements
$Statement = "[System.Enum]::Format([TaskState], {0}, '{1}')"

foreach ($Format in @('G', 'D', 'X', 'F')) {
    $StatementToDo  = $Statement -f 0, $Format
    $StatementDoing = $Statement -f "([TaskState]'Doing')", $Format
    $StatementDone  = $Statement -f '[TaskState]::Done', $Format
    $FormattedToDo  = [System.Enum]::Format(
      [TaskState], 0, $Format
    )
    $FormattedDoing = [System.Enum]::Format(
        [TaskState], ([TaskState]'Doing'), $Format
    )
    $FormattedDone  = [System.Enum]::Format(
      [TaskState], [TaskState]::Done, $Format
    )

    "{0,-62} => {1}" -f $StatementToDo,  $FormattedToDo
    "{0,-62} => {1}" -f $StatementDoing, $FormattedDoing
    "{0,-62} => {1}" -f $StatementDone,  $FormattedDone
}

    [System.Enum]::Format([TaskState], 0, 'G')                     => ToDo
[System.Enum]::Format([TaskState], ([TaskState]'Doing'), 'G')  => Doing
[System.Enum]::Format([TaskState], [TaskState]::Done, 'G')     => Done
[System.Enum]::Format([TaskState], 0, 'D')                     => 0
[System.Enum]::Format([TaskState], ([TaskState]'Doing'), 'D')  => 1
[System.Enum]::Format([TaskState], [TaskState]::Done, 'D')     => 2
[System.Enum]::Format([TaskState], 0, 'X')                     => 00000000
[System.Enum]::Format([TaskState], ([TaskState]'Doing'), 'X')  => 00000001
[System.Enum]::Format([TaskState], [TaskState]::Done, 'X')     => 00000002
[System.Enum]::Format([TaskState], 0, 'F')                     => ToDo
[System.Enum]::Format([TaskState], ([TaskState]'Doing'), 'F')  => Doing
[System.Enum]::Format([TaskState], [TaskState]::Done, 'F')     => Done

    获取枚举名称

    GetEnumName() 反射方法返回特定枚举值的名称。输入值必须是枚举的有效基础类型，例如整数或枚举值。如果有多个名称与一个值关联，则该方法返回第一个定义的名称。

    [<enum-name>].GetEnumName(<value>)

    enum GateState {
    Unknown
    Open
    Opening
    Closing
    Closed
}

foreach ($Value in 0..4) {
    [pscustomobject]@{
      IntegerValue = $Value
      EnumName     = [GateState].GetEnumName($Value)
    }
}

    IntegerValue EnumName
------------ --------
           0 Unknown
           1 Open
           2 Opening
           3 Closing
           4 Closed

    获取枚举名称

    GetEnumNames() 反射方法以字符串形式返回每个枚举值的名称。输出包括同义词。

    [<enum-name>].GetEnumNames()

    enum Season {
    Unknown
    Spring
    Summer
    Autumn
    Winter
    Fall   = 3
}

[Season].GetEnumNames()

    Unknown
Spring
Summer
Fall
Autumn
Winter

    获取Enum底层类型

    GetEnumUnderlyingType() 反射方法返回枚举值的基础类型。

    [<enum-name>].GetEnumUnderlyingType()

    enum IntBasedEnum {
    Zero
    One
    Two
}
enum ShortBasedEnum : short {
    Zero
    One
    Two
}

foreach ($EnumType in @([IntBasedEnum], [ShortBasedEnum])) {
    [pscustomobject]@{
        EnumType = $EnumType
        ValueType = $EnumType.GetEnumUnderlyingType()
    }
}

    EnumType       ValueType
--------       ---------
IntBasedEnum   System.Int32
ShortBasedEnum System.Int16

    获取枚举值

    GetEnumValues() 反射方法返回枚举的每个定义值。

    [<enum-name>].GetEnumValues()

    enum Season {
    Unknown
    Spring
    Summer
    Autumn
    Winter
    Fall   = 3
}

[Season].GetEnumValues()

    Unknown
Spring
Summer
Fall
Fall
Winter

    GetEnumValuesAsUnderlyingType

    GetEnumValuesAsUnderlyingType() 反射方法将枚举的每个定义值返回为基础类型。

    [<enum-name>].GetEnumValuesAsUnderlyingType()

    enum IntBasedEnum {
    Zero
    One
    Two
}
enum ShortBasedEnum : short {
    Zero
    One
    Two
}

foreach ($EnumType in @([IntBasedEnum], [ShortBasedEnum])) {
    [pscustomobject]@{
        EnumType = $EnumType
        ValueType = $EnumType.GetEnumValuesAsUnderlyingType()[0].GetType()
    }
}

    EnumType       ValueType
--------       ---------
IntBasedEnum   System.Int32
ShortBasedEnum System.Int16

    HasFlag

    HasFlag 实例方法确定是否为标志枚举值设置了位标志。与进行二进制比较和等价性检查相比，使用此方法更短且更易于阅读。

    <enum-value>.HasFlag(<enum-flag-value>)

    以下示例定义 ModuleFeatures 标志枚举并显示值 39 具有哪些标志。

    [Flags()] enum ModuleFeatures {
    Commands  = 1
    Classes   = 2
    Enums     = 4
    Types     = 8
    Formats   = 16
    Variables = 32
}

$Features = [ModuleFeatures]39

foreach ($Feature in [ModuleFeatures].GetEnumValues()) {
    "Has flag {0,-12}: {1}" -f "'$Feature'", ($Features.HasFlag($Feature))
}

    Has flag 'Commands'  : True
Has flag 'Classes'   : True
Has flag 'Enums'     : True
Has flag 'Types'     : False
Has flag 'Formats'   : False
Has flag 'Variables' : True

    IsDefined

    如果为枚举定义了输入值，则 IsDefined() 静态方法返回 $true，否则返回 $false。使用此方法可以检查值对于枚举是否有效，而无需处理无效参数错误。

    您可以在System.Enum基类类型或特定枚举类型上使用静态方法。

    [System.Enum]::IsDefined([<enum-name>], <value>)

    [<enum-name>]::IsDefined([<enum-name>], <value>)

    enum Season {
    Unknown
    Spring
    Summer
    Autumn
    Winter
    Fall   = 3
}

foreach ($Value in 0..5) {
    $IsValid   = [Season]::IsDefined([Season], $Value)
    $EnumValue = if ($IsValid) { [Season]$Value }

    [pscustomobject] @{
        InputValue = $Value
        IsValid    = $IsValid
        EnumValue  = $EnumValue
    }
}

    InputValue IsValid EnumValue
---------- ------- ---------
         0    True   Unknown
         1    True    Spring
         2    True    Summer
         3    True      Fall
         4    True    Winter
         5   False

    ToString

    ToString() 实例方法返回枚举值的标签。此方法也是枚举值如何显示为输出的默认视图。或者，您可以指定格式字符串来控制值的显示方式。有关格式化的详细信息，请参阅格式化枚举值。

    笔记

    对于为特定值定义同义词的枚举，请勿编写依赖于 ToString() 输出的代码。该方法可以返回该值的任何有效名称。

    <enum-value>.ToString([<format-string>])

    以下示例将 Shade 枚举定义为 Gray 作为 Grey 的同义词。然后，它输出显示实际枚举值的对象，其中枚举为字符串，枚举为整数。

    enum Shade {
    White
    Grey
    Gray = 1
    Black
}

[Shade].GetEnumValues() | Foreach-Object -Process {
    [pscustomobject]@{
        EnumValue    = $_
        StringValue  = $_.ToString()
        IntegerValue = [int]$_
    }
}

    numValue StringValue IntegerValue
--------- ----------- ------------
    White White                  0
     Grey Grey                   1
     Grey Grey                   1
    Black Black                  2

    枚举值同义词

    您可以定义为同一整数值赋予不同名称的枚举。当您这样做时，指向相同基础值的名称称为同义词。具有同义词的枚举使用户能够为相同的值指定不同的名称。

    当您使用同义词定义枚举时，请勿编写依赖于将同义词值转换为特定名称的代码。您可以可靠地编写将同义词字符串转换为枚举值的代码。使用枚举值本身时，始终将其作为枚举值或其基础类型进行比较，而不是作为字符串进行比较。

    以下代码块定义 Shade 枚举，并将 Grey 和 Gray 作为同义词。

    enum Shade {
    White
    Grey
    Gray = 1
    Black
}

[Shade]'Grey' -eq [Shade]::Gray
[Shade]::Grey -eq 1
[Shade]'Gray' -eq 1

    True
True
True

    枚举作为标志

    枚举的一个常见用途是表示一组互斥的值。例如，ArrivalStatus 实例的值可以是 Early、OnTime 或 Late。 ArrivalStatus 实例的值反映多个枚举常量是没有意义的。

    然而，在其他情况下，枚举对象的值可以包含多个枚举成员，每个成员代表枚举值中的一个位字段。您可以使用 FlagsAttribute 来指示枚举由位字段组成，作为用户可以组合的标志。

    为了使枚举作为标志正常工作，必须将每个标签的整数值设置为 2 的幂。如果不指定标签的值，PowerShell 会将该值设置为比前一个标签大一的值。

    您可以定义常用标志组合的值，以便用户更轻松地一次指定一组标志。值的名称应该是标志的组合名称。整数值应该是标志值的总和。

    要确定是否为某个值设置了特定标志，请对该值使用 HasFlag() 方法或使用二进制比较运算符 -band。

    有关显示如何使用标志枚举并检查是否设置标志的示例，请参阅示例 3。

    枚举作为参数

    您可以定义使用枚举作为其类型的 cmdlet 参数。当您指定枚举作为参数的类型时，用户可以自动完成参数值并对其进行验证。参数完成建议枚举的有效标签列表。

    当参数的类型为枚举时，您可以指定以下任意一项：

    • 枚举，例如 []::X 或 x 和 F 或 f ）来转换 TaskState 枚举的每个成员其字符串表示形式。
      enum TaskState {
    ToDo
    Doing
    Done
}

[TaskState].GetEnumValues() | ForEach-Object {
    [pscustomobject]@{
        "ToString('G')" = $_.ToString('G')
        "ToString('D')" = $_.ToString('D')
        "ToString('X')" = $_.ToString('X')
        "ToString('F')" = $_.ToString('F')
    }
}

      ToString('G') ToString('D') ToString('X') ToString('F')
------------- ------------- ------------- -------------
ToDo          0             00000000      ToDo
Doing         1             00000001      Doing
Done          2             00000002      Done

      以下示例使用标志枚举值的格式字符串。

      [Flags()] enum FlagEnum {
    A = 1
    B = 2
    C = 4
}

$FlagValues = @(
    [FlagEnum]::A                                 # 1
    [FlagEnum]::B                                 # 2
    [FlagEnum]::A + [FlagEnum]::B                 # 3
    [FlagEnum]::C                                 # 4
    [FlagEnum]::C + [FlagEnum]::A                 # 5
    [FlagEnum]::C + [FlagEnum]::B                 # 6
    [FlagEnum]::C + [FlagEnum]::A + [FlagEnum]::B # 7
    [FlagEnum]::C + [FlagEnum]::C                 # 8
)

foreach ($Value in $FlagValues) {
    [pscustomobject]@{
        "ToString('G')" = $Value.ToString('G')
        "ToString('D')" = $Value.ToString('D')
        "ToString('X')" = $Value.ToString('X')
        "ToString('F')" = $Value.ToString('F')
    }
}

      ToString('G') ToString('D') ToString('X') ToString('F')
------------- ------------- ------------- -------------
A             1             00000001      A
B             2             00000002      B
A, B          3             00000003      A, B
C             4             00000004      C
A, C          5             00000005      A, C
B, C          6             00000006      B, C
A, B, C       7             00000007      A, B, C
8             8             00000008      8

      请注意，对于标志枚举，G 和 F 格式字符串显示以逗号分隔的值的设置标志列表。最后一个值 8 未列出任何标志，因为它实际上不是有效的标志集。如果不复制至少一个标志，则无法组合枚举标志来获得 8 之和。

      使用 Update-TypeData 定义扩展方法

      您不能在枚举的声明中定义方法。要扩展枚举的功能，您可以使用 Update-TypeData cmdlet 定义枚举的 ScriptMethod 成员。

      以下示例使用 Update-TypeData cmdlet 将 GetFlags() 方法添加到 FileAttributes 标志枚举。它返回为该值设置的标志数组。

      [Flags()] enum FileAttributes {
    Archive    = 1
    Compressed = 2
    Device     = 4
    Directory  = 8
    Encrypted  = 16
    Hidden     = 32
}

$MemberDefinition = @{
    TypeName   = 'FileAttributes'
    MemberName = 'GetFlags'
    MemberType = 'ScriptMethod'
    Value      = {
        foreach ($Flag in $this.GetType().GetEnumValues()) {
          if ($this.HasFlag($Flag)) { $Flag }
        }
    }
}

Update-TypeData @MemberDefinition

$File = [FileAttributes]28

$File.GetFlags()

      Device
Directory
Encrypted

      使用类型加速器导出枚举

      默认情况下，PowerShell 模块不会自动导出 PowerShell 中定义的类和枚举。如果不调用 using module 语句，自定义类型在模块外部不可用。

      但是，如果模块添加类型加速器，则在用户导入该模块后，这些类型加速器将立即在会话中可用。

      笔记

      向会话添加类型加速器使用内部（非公共）API。使用此 API 可能会导致冲突。如果导入模块时已存在同名的类型加速器，则下面描述的模式会引发错误。当您从会话中删除模块时，它还会删除类型加速器。

      此模式确保类型在会话中可用。在 VS Code 中创作脚本文件时，它不会影响 IntelliSense 或完成。要在 VS Code 中获取自定义类型的 IntelliSense 和补全建议，您需要在脚本顶部添加 using module 语句。

      以下模式展示了如何将 PowerShell 类和枚举注册为模块中的类型加速器。在任何类型定义之后将代码片段添加到根脚本模块。确保 $ExportableTypes 变量包含您希望在用户导入模块时提供给用户的每种类型。其他代码不需要任何编辑。

      # Define the types to export with type accelerators.
$ExportableTypes =@(
    [DefinedTypeName]
)
# Get the internal TypeAccelerators class to use its static methods.
$TypeAcceleratorsClass = [psobject].Assembly.GetType(
    'System.Management.Automation.TypeAccelerators'
)
# Ensure none of the types would clobber an existing type accelerator.
# If a type accelerator with the same name exists, throw an exception.
$ExistingTypeAccelerators = $TypeAcceleratorsClass::Get
foreach ($Type in $ExportableTypes) {
    if ($Type.FullName -in $ExistingTypeAccelerators.Keys) {
        $Message = @(
            "Unable to register type accelerator '$($Type.FullName)'"
            'Accelerator already exists.'
        ) -join ' - '

        throw [System.Management.Automation.ErrorRecord]::new(
            [System.InvalidOperationException]::new($Message),
            'TypeAcceleratorAlreadyExists',
            [System.Management.Automation.ErrorCategory]::InvalidOperation,
            $Type.FullName
        )
    }
}
# Add type accelerators for every exportable type.
foreach ($Type in $ExportableTypes) {
    $TypeAcceleratorsClass::Add($Type.FullName, $Type)
}
# Remove type accelerators when the module is removed.
$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
    foreach($Type in $ExportableTypes) {
        $TypeAcceleratorsClass::Remove($Type.FullName)
    }
}.GetNewClosure()

      当用户导入模块时，添加到会话类型加速器的任何类型都可立即用于 IntelliSense 和完成。当模块被删除时，类型加速器也会被删除。

      从 PowerShell 模块手动导入枚举

      Import-Module 和 #requires 语句仅导入模块定义的模块函数、别名和变量。不导入枚举。

      如果模块定义了类和枚举，但没有为这些类型添加类型加速器，请使用 using module 语句导入它们。

      using module 语句从脚本模块或二进制模块的根模块 (ModuleToProcess) 导入类和枚举。它不会始终导入嵌套模块中定义的类或点源到根模块的脚本中定义的类。直接在根模块中定义您希望模块外部的用户可以使用的类。

      有关 using 语句的更多信息，请参阅 about_Using。

      在开发过程中加载新更改的代码

      在开发脚本模块期间，通常会对代码进行更改，然后使用 Import-Module 和 Force 参数加载新版本的模块。这仅适用于根模块中函数的更改。 Import-Module 不会重新加载任何嵌套模块。此外，无法加载任何更新的类。

      为了确保您运行的是最新版本，您必须启动一个新会话。无法卸载在 PowerShell 中定义并使用 using 语句导入的类和枚举。

      另一种常见的开发实践是将代码分成不同的文件。如果一个文件中的函数使用在另一模块中定义的枚举，则应使用 using module 语句来确保这些函数具有所需的枚举定义。

      局限性

      • 您不能使用属性来修饰 PowerShell 中定义的枚举值。您只能修饰枚举声明本身，就像使用 FlagsAttribute 将枚举定义为一组位标志一样。

        解决方法：无

      • 您无法在枚举定义中定义方法，并且 PowerShell 不支持像 C# 那样定义[扩展方法]。

        解决方法：使用 Update-TypeData cmdlet 定义枚举的 ScriptMethod 成员。

    猜你还喜欢

    您需要 登录账户 后才能发表评论

    取消回复欢迎 你 发表评论:

    精品推荐！
    欢迎 访客 登录没有账号？
    • 最新文章
    • 热门文章
    • 热评文章
    最新评论
      热门tag
      友情链接

      关灯