ತರಗತಿಗಳೊಂದಿಗೆ ಕ್ರಿಯಾತ್ಮಕ ಪವರ್‌ಶೆಲ್ ಆಕ್ಸಿಮೋರಾನ್ ಅಲ್ಲ, ನಾನು ಅದನ್ನು ಖಾತರಿಪಡಿಸುತ್ತೇನೆ

ಹೇ ಹಬ್ರ್! ನಾನು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಲೇಖನದ ಅನುವಾದವನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇನೆ "ಕ್ಲಾಸ್‌ಗಳೊಂದಿಗೆ ಕ್ರಿಯಾತ್ಮಕ ಪವರ್‌ಶೆಲ್.
ಇದು ಆಕ್ಸಿಮೋರಾನ್ ಅಲ್ಲ ಎಂದು ನಾನು ಭರವಸೆ ನೀಡುತ್ತೇನೆ" ಕ್ರಿಸ್ಟೋಫರ್ ಕುಯೆಚ್ ಅವರಿಂದ.

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳು ಪರಸ್ಪರ ಭಿನ್ನಾಭಿಪ್ರಾಯವನ್ನು ತೋರಬಹುದು, ಆದರೆ ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಎರಡೂ ಸಮಾನವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ. ಬಹುತೇಕ ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು, ಕ್ರಿಯಾತ್ಮಕ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೂ, ವಿಸ್ತೃತ ಹೆಸರು-ಮೌಲ್ಯ ಬೈಂಡಿಂಗ್ ಸೌಲಭ್ಯಗಳನ್ನು ಹೊಂದಿವೆ; ಸ್ಟ್ರಕ್ಟ್‌ಗಳು ಮತ್ತು ದಾಖಲೆಗಳಂತಹ ತರಗತಿಗಳು ಕೇವಲ ಒಂದು ವಿಧಾನವಾಗಿದೆ. ನಾವು ವರ್ಗಗಳ ಬಳಕೆಯನ್ನು ಹೆಸರುಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳ ಬೈಂಡಿಂಗ್‌ಗೆ ಸೀಮಿತಗೊಳಿಸಿದರೆ ಮತ್ತು ಆನುವಂಶಿಕತೆ, ಬಹುರೂಪತೆ ಅಥವಾ ರೂಪಾಂತರದಂತಹ ಭಾರೀ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ತಪ್ಪಿಸಿದರೆ, ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸದೆಯೇ ನಾವು ಅವುಗಳ ಪ್ರಯೋಜನಗಳ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು. ಇದಲ್ಲದೆ, ಬದಲಾಗದ ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ ವಿಧಾನಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ನಾವು ನಮ್ಮ ಕ್ರಿಯಾತ್ಮಕ ಕೋಡ್ ಅನ್ನು ತರಗತಿಗಳೊಂದಿಗೆ ಉತ್ಕೃಷ್ಟಗೊಳಿಸಬಹುದು.

ಜಾತಿಗಳ ಮಾಯಾಜಾಲ

ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಜಾತಿಗಳು ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನೀವು ಮೌಲ್ಯವನ್ನು ಬಿತ್ತರಿಸಿದಾಗ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪರಿಸರವು ಸೇರಿಸುವ ಸೂಚ್ಯ ಪ್ರಾರಂಭ ಮತ್ತು ಮೌಲ್ಯೀಕರಣ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀವು ಅವಲಂಬಿಸಿರುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ, ಸರಳವಾಗಿ [xml] ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಿತ್ತರಿಸುವುದು ಪಾರ್ಸರ್ ಕೋಡ್ ಮೂಲಕ ರನ್ ಆಗುತ್ತದೆ ಮತ್ತು ಸಂಪೂರ್ಣ xml ಟ್ರೀ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಅದೇ ಉದ್ದೇಶಕ್ಕಾಗಿ ನಾವು ನಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ತರಗತಿಗಳನ್ನು ಬಳಸಬಹುದು.

ಹ್ಯಾಶ್‌ಟೇಬಲ್‌ಗಳನ್ನು ಬಿತ್ತರಿಸಿ

ನೀವು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ನಿಮ್ಮ ಕ್ಲಾಸ್ ಪ್ರಕಾರಕ್ಕೆ ಹ್ಯಾಶ್‌ಟೇಬಲ್ ಅನ್ನು ಬಿತ್ತರಿಸುವ ಮೂಲಕ ನೀವು ಒಂದಿಲ್ಲದೇ ಮುಂದುವರಿಸಬಹುದು. ಈ ಮಾದರಿಯ ಸಂಪೂರ್ಣ ಪ್ರಯೋಜನವನ್ನು ಪಡೆಯಲು ಮೌಲ್ಯೀಕರಣ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಲು ಮರೆಯಬೇಡಿ. ಅದೇ ಸಮಯದಲ್ಲಿ, ನಾವು ಇನ್ನೂ ಆಳವಾದ ಆರಂಭ ಮತ್ತು ಮೌಲ್ಯೀಕರಣ ತರ್ಕವನ್ನು ಚಲಾಯಿಸಲು ವರ್ಗದ ಟೈಪ್ ಮಾಡಿದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಬಹುದು.

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index
}

[Cluster]@{
    Service       = "MyService"
    FlightingRing = "PROD"
    Region        = "EastUS"
    Index         = 2
}

ಜೊತೆಗೆ, ಕ್ಯಾಸ್ಟಿಂಗ್ ಕ್ಲೀನ್ ಔಟ್ಪುಟ್ ಪಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಫಾರ್ಮ್ಯಾಟ್-ಟೇಬಲ್‌ಗೆ ರವಾನಿಸಲಾದ ಕ್ಲಸ್ಟರ್ ಹ್ಯಾಶ್‌ಟೇಬಲ್ ರಚನೆಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀವು ಮೊದಲು ಈ ಹ್ಯಾಶ್‌ಟೇಬಲ್‌ಗಳನ್ನು ವರ್ಗಕ್ಕೆ ಬಿತ್ತರಿಸಿದರೆ ನೀವು ಪಡೆಯುವದನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ. ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಯಾವಾಗಲೂ ಅಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕ್ರಮದಲ್ಲಿ ಪಟ್ಟಿಮಾಡಲಾಗುತ್ತದೆ. ಫಲಿತಾಂಶಗಳಲ್ಲಿ ನೀವು ಗೋಚರಿಸಲು ಬಯಸದ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳ ಮೊದಲು ಗುಪ್ತ ಕೀವರ್ಡ್ ಅನ್ನು ಸೇರಿಸಲು ಮರೆಯಬೇಡಿ.

ಅರ್ಥಗಳ ಎರಕಹೊಯ್ದ

ನೀವು ಒಂದು ವಾದವನ್ನು ಹೊಂದಿರುವ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಹೊಂದಿದ್ದರೆ, ನಿಮ್ಮ ವರ್ಗದ ಪ್ರಕಾರಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ಬಿತ್ತರಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ನಿಮ್ಮ ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index

    Cluster([string] $id) {
        $this.Service, $this.FlightingRing, $this.Region, $this.Index = $id -split "-"
    }
}

[Cluster]"MyService-PROD-EastUS-2"

ಸಾಲಿಗೆ ಬಿತ್ತರಿಸು

ಸ್ಟ್ರಿಂಗ್ ಇಂಟರ್ಪೋಲೇಶನ್ ಅನ್ನು ಬಳಸುವಂತಹ ವಸ್ತುವಿನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯದ ಹಿಂದಿನ ತರ್ಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು [ಸ್ಟ್ರಿಂಗ್] ToString() ವರ್ಗ ವಿಧಾನವನ್ನು ಸಹ ಅತಿಕ್ರಮಿಸಬಹುದು.

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index

    [string] ToString() {
        return $this.Service, $this.FlightingRing, $this.Region, $this.Index -join "-"
    }
}

$cluster = [Cluster]@{
    Service       = "MyService"
    FlightingRing = "PROD"
    Region        = "EastUS"
    Index         = 2
}

Write-Host "We just created a model for '$cluster'"

ಬಿತ್ತರಿಸಿದ ಧಾರಾವಾಹಿ ನಿದರ್ಶನಗಳು

ಎರಕಹೊಯ್ದವು ಸುರಕ್ಷಿತ ಡೀರಿಯಲೈಸೇಶನ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಡೇಟಾವು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ನಮ್ಮ ವಿವರಣೆಯನ್ನು ಪೂರೈಸದಿದ್ದರೆ ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳು ವಿಫಲಗೊಳ್ಳುತ್ತವೆ

# Валидация сериализованных данных

[Cluster]$cluster = Get-Content "./my-cluster.json" | ConvertFrom-Json
[Cluster[]]$clusters = Import-Csv "./my-clusters.csv"

ನಿಮ್ಮ ಕ್ರಿಯಾತ್ಮಕ ಕೋಡ್‌ನಲ್ಲಿರುವ ಜಾತಿಗಳು

ಕ್ರಿಯಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳು ಮೊದಲು ಡೇಟಾ ರಚನೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ, ನಂತರ ಬದಲಾಗದ ಡೇಟಾ ರಚನೆಗಳ ಮೇಲೆ ರೂಪಾಂತರಗಳ ಅನುಕ್ರಮವಾಗಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ. ವ್ಯತಿರಿಕ್ತ ಅನಿಸಿಕೆಗಳ ಹೊರತಾಗಿಯೂ, ವರ್ಗಗಳು ನಿಜವಾಗಿಯೂ ನಿಮಗೆ ಕ್ರಿಯಾತ್ಮಕ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.

ನಾನು ಬರೆಯುತ್ತಿರುವ ಪವರ್‌ಶೆಲ್ ಕ್ರಿಯಾತ್ಮಕವಾಗಿದೆಯೇ?

C# ಅಥವಾ ಅಂತಹುದೇ ಹಿನ್ನೆಲೆಯಿಂದ ಬರುವ ಬಹಳಷ್ಟು ಜನರು ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಬರೆಯುತ್ತಿದ್ದಾರೆ, ಇದು C# ಗೆ ಹೋಲುತ್ತದೆ. ಇದನ್ನು ಮಾಡುವ ಮೂಲಕ, ನೀವು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಬಳಸುವುದರಿಂದ ದೂರ ಸರಿಯುತ್ತಿರುವಿರಿ ಮತ್ತು ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಹೆಚ್ಚು ಡೈವಿಂಗ್ ಮಾಡುವುದರಿಂದ ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದು.

ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು (|), ಎಲ್ಲಿ-ವಸ್ತು, ಪ್ರತಿ-ಆಬ್ಜೆಕ್ಟ್, ಸೆಲೆಕ್ಟ್-ಆಬ್ಜೆಕ್ಟ್, ಗ್ರೂಪ್-ಆಬ್ಜೆಕ್ಟ್, ವಿಂಗಡಣೆ-ವಸ್ತು, ಇತ್ಯಾದಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬದಲಾಯಿಸಲಾಗದ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸುವುದರ ಮೇಲೆ ನೀವು ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದ್ದರೆ - ನೀವು ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ಶೈಲಿಯನ್ನು ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ನೀವು ಪ್ರಯೋಜನ ಪಡೆಯುತ್ತೀರಿ. ಕ್ರಿಯಾತ್ಮಕ ಶೈಲಿಯಲ್ಲಿ ತರಗತಿಗಳು.

ತರಗತಿಗಳ ಕ್ರಿಯಾತ್ಮಕ ಬಳಕೆ

ಜಾತಿಗಳು, ಅವರು ಪರ್ಯಾಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ, ಎರಡು ಡೊಮೇನ್‌ಗಳ ನಡುವಿನ ಮ್ಯಾಪಿಂಗ್ ಮಾತ್ರ. ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ, ForEach-Object ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, Datum ಅನ್ನು ಬಿತ್ತರಿಸಿದಾಗ ಪ್ರತಿ ಬಾರಿ ನೋಡ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇದು ನಮಗೆ ನ್ಯಾಯೋಚಿತ ಪ್ರಮಾಣದ ಕೋಡ್ ಅನ್ನು ಬರೆಯದಿರುವ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ. ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಪೈಪ್‌ಲೈನ್ ಘೋಷಣಾತ್ಮಕ ಡೇಟಾ ವಿಚಾರಣೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ, ಆದರೆ ನಮ್ಮ ತರಗತಿಗಳು ಡೇಟಾ ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಮೌಲ್ಯೀಕರಣವನ್ನು ನೋಡಿಕೊಳ್ಳುತ್ತವೆ.

# Пример комбинирования классов с конвейерами для separation of concerns в конвейерах

class Node {
    [ValidateLength(3, 7)]
    [string] $Name
    [ValidateSet("INT", "PPE", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope", "WestEurope")]
    [string] $Region
    Node([string] $Name) {
        $Name -match "([a-z]+)(INT|PPE|PROD)([a-z]+)"
        $_, $this.Service, $this.FlightingRing, $this.Region = $Matches
        $this.Name = $Name
    }
}

class Datum {
    [string] $Name
    [int] $Value
    [Node] $Computer
    [int] Severity() {
        $this.Name -match "[0-9]+$"
        return $Matches[0]
    }
}

Write-Host "Urgent Security Audit Issues:"
Import-Csv "./audit-results.csv" `
    | ForEach-Object {[Datum]$_} `
    | Where-Object Value -gt 0 `
    | Group-Object {$_.Severity()} `
    | Where-Object Name -lt 2 `
    | ForEach-Object Group `
    | ForEach-Object Computer `
    | Where-Object FlightingRing -eq "PROD" `
    | Sort-Object Name, Region -Unique

ಮರುಬಳಕೆಗಾಗಿ ಪ್ಯಾಕೇಜಿಂಗ್ ವರ್ಗ

ಯಾವುದೂ ಅಂದುಕೊಂಡಷ್ಟು ಚೆನ್ನಾಗಿಲ್ಲ

ದುರದೃಷ್ಟವಶಾತ್, ಕಾರ್ಯಗಳು ಅಥವಾ ಅಸ್ಥಿರಗಳಂತೆಯೇ ಮಾಡ್ಯೂಲ್‌ಗಳಿಂದ ತರಗತಿಗಳನ್ನು ರಫ್ತು ಮಾಡಲಾಗುವುದಿಲ್ಲ; ಆದರೆ ಕೆಲವು ತಂತ್ರಗಳಿವೆ. ನಿಮ್ಮ ತರಗತಿಗಳನ್ನು ./my-classes.ps1 ಫೈಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳೋಣ

• ನೀವು ತರಗತಿಗಳೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ಡಾಟ್ಸೋರ್ಸ್ ಮಾಡಬಹುದು :. ./my-classes.ps1. ಇದು ನಿಮ್ಮ ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ my-classes.ps1 ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅಲ್ಲಿರುವ ಫೈಲ್‌ನಿಂದ ಎಲ್ಲಾ ವರ್ಗಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.

• ನಿಮ್ಮ ಎಲ್ಲಾ ಕಸ್ಟಮ್ API ಗಳನ್ನು (cmdlets) ರಫ್ತು ಮಾಡುವ ಪವರ್‌ಶೆಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ನೀವು ರಚಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಮ್ಯಾನಿಫೆಸ್ಟ್‌ನಲ್ಲಿ ScriptsToProcess = "./my-classes.ps1" ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೊಂದಿಸಬಹುದು, ಅದೇ ಫಲಿತಾಂಶದೊಂದಿಗೆ: ./my-classes.ps1 ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ ನಿಮ್ಮ ಪರಿಸರ.

ನೀವು ಯಾವುದೇ ಆಯ್ಕೆಯನ್ನು ಆರಿಸಿಕೊಂಡರೂ, ಪವರ್‌ಶೆಲ್‌ನ ಪ್ರಕಾರದ ವ್ಯವಸ್ಥೆಯು ವಿವಿಧ ಸ್ಥಳಗಳಿಂದ ಲೋಡ್ ಮಾಡಲಾದ ಒಂದೇ ಹೆಸರಿನ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಹರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.
ನೀವು ಬೇರೆ ಬೇರೆ ಸ್ಥಳಗಳಿಂದ ಒಂದೇ ರೀತಿಯ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಎರಡು ಒಂದೇ ವರ್ಗಗಳನ್ನು ಲೋಡ್ ಮಾಡಿದರೂ ಸಹ, ನೀವು ಸಮಸ್ಯೆಗಳಿಗೆ ಸಿಲುಕುವ ಅಪಾಯವಿದೆ.

ಮುಂದಿನ ದಾರಿ

ಟೈಪ್ ರೆಸಲ್ಯೂಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ ನಿಮ್ಮ ತರಗತಿಗಳನ್ನು ಬಳಕೆದಾರರಿಗೆ ಎಂದಿಗೂ ಬಹಿರಂಗಪಡಿಸುವುದು. ವರ್ಗ-ವ್ಯಾಖ್ಯಾನಿತ ಪ್ರಕಾರವನ್ನು ಬಳಕೆದಾರರು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ನಿರೀಕ್ಷಿಸುವ ಬದಲು, ವರ್ಗವನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸುವ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುವ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಕಾರ್ಯವನ್ನು ರಫ್ತು ಮಾಡಿ. ಕ್ಲಸ್ಟರ್‌ಗಾಗಿ, ನಾವು ಹೊಸ-ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯವನ್ನು ರಫ್ತು ಮಾಡಬಹುದು ಅದು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಪ್ಯಾರಾಮೀಟರ್ ಸೆಟ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index
}

function New-Cluster {
    [OutputType([Cluster])]
    Param(
        [Parameter(Mandatory, ParameterSetName = "Id", Position = 0)]
        [ValidateNotNullOrEmpty()]
        [string] $Id,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $Service,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $FlightingRing,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $Region,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [int] $Index
    )

    if ($Id) {
        $Service, $FlightingRing, $Region, $Index = $Id -split "-"
    }

    [Cluster]@{
        Service       = $Service
        FlightingRing = $FlightingRing
        Region        = $Region
        Index         = $Index
    }
}

Export-ModuleMember New-Cluster

ಇನ್ನೇನು ಓದಬೇಕು

ತರಗತಿಗಳ ಬಗ್ಗೆ
ರಕ್ಷಣಾತ್ಮಕ ಪವರ್‌ಶೆಲ್
ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್

ಮೂಲ: www.habr.com