Mastering PowerShell Scripting - Fourth Edition

Spis treści książki

• Preface
  • Who this book is for
  • What this book covers
  • To get the most out of this book
  • Get in touch
• Introduction to PowerShell
  • What is PowerShell?
  • PowerShell editors
  • Getting help
    • Updatable help
    • The Get-Help command
      • Syntax
      • Examples
      • Parameter
      • Detailed and Full switches
    • Save-Help
    • Update-Help
    • About_* help files
  • Command naming and discovery
    • Verbs
    • Nouns
    • Finding commands
    • Aliases
  • Parameters, values, and parameter sets
    • Parameters
      • Optional parameters
      • Optional positional parameters
      • Mandatory parameters
      • Mandatory positional parameters
      • Switch parameters
    • Parameter values
    • Parameter sets
    • Common parameters
    • Confirm and WhatIf
      • Confirm and ConfirmPreference
      • WhatIf and WhatIfPreference
    • Force parameter
    • PassThru parameter
  • Introduction to providers
    • Drives and providers
  • Introduction to splatting
    • Splatting to avoid long lines
    • Conditional use of parameters
    • Splatting to avoid repetition
    • Splatting and positional parameters
  • Parser modes
  • Experimental features
  • Summary
• Modules and Snap-Ins
  • Introducing modules
    • The Get-Module command
    • The Import-Module command
    • The Remove-Module command
    • PSModulePath in PowerShell
    • Using Windows PowerShell modules in PowerShell 7
  • Finding and installing modules
    • What is the PowerShell Gallery?
    • The Find-Module command
    • The Install-Module command
    • The Update-Module command
    • The Save-Module command
  • PowerShellGet 3.0
    • Repositories
    • Version ranges
  • PowerShell repositories
    • Creating an SMB repository
    • NuGet repositories
  • About snap-ins
  • Summary
• Working with Objects in PowerShell
  • Pipelines
    • Standard output
    • Non-standard output
    • The object pipeline
  • Members
    • The Get-Member command
    • Accessing object properties
    • Access modifiers
    • Using methods
    • The Add-Member command
  • Enumerating and filtering
    • The ForEach-Object command
      • Begin and End parameters
      • The Parallel parameter
      • The MemberName parameter
    • The Where-Object command
  • Selecting and sorting
    • The Select-Object command
      • Calculated properties
      • The ExpandProperty parameter
      • The Unique parameter
      • Property sets
    • The Sort-Object command
  • Grouping and measuring
    • The Group-Object command
    • The Measure-Object command
  • Comparing
  • Importing, exporting, and converting
    • The Export-Csv command
    • The Import-Csv command
    • Export-Clixml and Import-Clixml
    • The Tee-Object command
  • Summary
• Operators
  • Arithmetic operators
    • Operator precedence
    • Addition and subtraction operators
      • Addition operator
      • Subtraction operator
    • Multiplication, division, and remainder operators
      • Multiplication operator
      • Division operator
      • Remainder operator
  • Assignment operators
    • Assign, add and assign, and subtract and assign
    • Multiply and assign, divide and assign, and modulus and assign
    • Statements can be assigned to a variable
  • Comparison operators
    • Case sensitivity
    • Comparison operators and arrays
    • Comparisons to null
    • Equal to and not equal to
    • Like and not like
    • Greater than and less than
    • Contains and in
  • Regular expression-based operators
    • Match and not match
    • Replace
    • Split
  • Logical operators
    • And
    • Or
    • Exclusive or
    • Not
  • Binary operators
    • Binary and
    • Binary or
    • Binary exclusive or
    • Binary not
    • Shift left and shift right operators
  • Type operators
    • As
    • is and isnot
  • Redirection operators
    • Redirection to a file
    • Redirecting streams to standard output
    • Redirection to null
  • Other operators
    • Call
    • Comma
    • Format
    • Increment and decrement
    • Join
    • Ternary
    • Null coalescing
    • Null coalescing assignment
    • Null conditional
    • Pipeline chain
    • Background
  • Summary
• Variables, Arrays, and Hashtables
  • Naming and creating variables
  • Objects assigned to variables
  • Variable commands
    • Clear-Variable
    • Get-Variable
    • New-Variable
    • Remove-Variable
    • Set-Variable
  • Variable provider
  • Scopes and variables
    • Accessing variables
    • Scope modifiers
    • Numeric scopes
    • Private variables
  • Types and type conversion
    • Typed numeric values
  • Arrays
    • Creating an array
    • Arrays with a type
    • Adding elements to an array
    • Selecting elements from an array
    • Changing element values in an array
    • Removing elements
      • Removing elements by index
      • Removing elements by value
    • Clearing an array
    • Filling variables from arrays
    • Multi-dimensional and jagged arrays
  • Hashtables
    • Creating a Hashtable
    • Adding and changing Hashtable elements
    • Selecting elements from a Hashtable
    • Enumerating a Hashtable
    • Removing elements from a Hashtable
  • Lists, dictionaries, queues, and stacks
    • System.Collections.Generic.List
      • Creating a list
      • Adding elements to the list
      • Selecting elements from the list
      • Removing elements from the list
      • Changing element values in a list
    • System.Collections.Generic.Dictionary
      • Creating a dictionary
      • Adding and changing elements in a dictionary
      • Selecting elements from a dictionary
      • Enumerating a dictionary
      • Removing elements from a dictionary
    • System.Collections.Generic.Queue
      • Creating a queue
      • Enumerating the queue
      • Adding elements to the queue
      • Removing elements from the queue
    • System.Collections.Generic.Stack
      • Creating a stack
      • Enumerating the stack
      • Adding elements to the stack
      • Removing elements from the stack
  • Summary
• Conditional Statements and Loops
  • if, else, and elseif
    • Assignment within if statements
  • switch
    • switch and arrays
    • switch and files
    • wildcard and regex
    • Script block cases
    • Switch, break, and continue
  • Loops
    • Foreach loop
    • for loop
    • do until and do while loops
    • While loop
  • Loops, break, and continue
    • Break and continue outside loops
    • Loops and labels
  • Implicit Boolean
  • Summary
• Working with .NET
  • Assemblies
    • About the Global Assembly Cache
  • Types
  • Enumerations
  • Classes
  • Namespaces
  • The using keyword
    • Using namespaces
    • Using assemblies
  • Type accelerators
  • Members
    • Constructors
    • Properties
    • Methods
      • Fluent interfaces
    • Static methods
      • About the new method
    • Static properties
  • Reflection in PowerShell
    • The TypeAccelerators type
    • The ArgumentTypeConverterAttribute type
  • Summary
• Strings, Numbers, and Dates
  • Manipulating strings
    • Indexing into strings
    • Substring
    • Split
    • Replace
    • Trim, TrimStart, and TrimEnd
    • Insert and Remove
    • IndexOf and LastIndexOf
    • PadLeft and PadRight
    • ToUpper, ToLower, and ToTitleCase
    • Contains, StartsWith, and EndsWith
    • String methods and arrays
    • Chaining methods
  • Converting strings
    • The *-Csv commands
    • ConvertFrom-StringData
    • Convert-String
    • ConvertFrom-String
    • Working with Base64
  • Manipulating numbers
    • Large byte values
    • Power of 10
    • Hexadecimal
    • Using System.Math
    • Converting strings into numeric values
  • Manipulating dates and times
    • Parsing dates
    • Changing dates
    • DateTime parameters
    • Comparing dates
  • Summary
• Regular Expressions
  • Regex basics
    • Literal characters
    • Any character (.)
    • Repetition with * and +
    • The escape character (\)
    • Optional characters
    • Non-printable characters
    • Debugging regular expressions
  • Anchors
  • Quantifiers
    • Exploring the quantifiers
  • Character classes
    • Ranges
    • Negated character class
    • Character class subtraction
    • Shorthand character classes
    • Unicode category class
  • Alternation
  • Grouping
    • Repeating groups
    • Restricting alternation
    • Capturing values
      • Named capture groups
      • Non-capturing groups
  • Look-ahead and look-behind
  • The .NET Regex type
  • Regex options
  • Examples of regular expressions
    • MAC addresses
    • IP addresses
    • The netstat command
    • Formatting certificates
  • Summary
• Files, Folders, and the Registry
  • Working with providers
    • Navigating
    • Getting items
    • Drives
    • Creating providers
  • Items
    • Testing for existing items
    • Creating and deleting items
    • Invoking items
    • Item properties
      • Properties and the filesystem
      • Adding and removing file attributes
    • Registry values
  • Windows permissions
    • Access and audit
    • Rule protection
    • Inheritance and propagation flags
    • Removing ACEs
    • Copying lists and entries
    • Adding ACEs
      • Filesystem rights
      • Registry rights
      • Numeric values in the ACL
    • Ownership
  • Transactions
  • File catalog commands
    • New-FileCatalog
    • Test-FileCatalog
  • Summary
• Windows Management Instrumentation
  • Working with WMI
    • WMI classes
    • WMI commands
  • CIM cmdlets
    • Getting instances
    • Getting classes
    • Calling methods
    • Creating instances
    • Working with CIM sessions
    • Associated classes
  • The WMI Query Language
    • Understanding SELECT, WHERE, and FROM
    • Escape sequences and wildcards
    • Logic operators
    • Comparison operators
    • Quoting values
    • Associated classes
      • WMI object paths
      • Using ASSOCIATORS OF
  • WMI Type Accelerators
    • Getting instances
    • Working with dates
    • Getting classes
    • Calling methods
    • Creating instances
    • Associated classes
  • Permissions
    • Sharing permissions
      • Creating a shared directory
      • Getting a security descriptor
      • Adding an access control entry
      • Setting the security descriptor
    • WMI permissions
      • Getting a security descriptor
      • The access mask
    • WMI and SDDL
  • Summary
• Working with HTML, XML, and JSON
  • HTML
    • ConvertTo-Html
    • Multiple tables
    • Adding style
    • HTML and special characters
  • XML commands
    • About XML
      • Elements and attributes
      • Namespaces
      • Schemas
    • Select-Xml
    • Select-Xml and namespaces
    • ConvertTo-Xml
  • System.Xml
    • The XML type accelerator
    • XPath and XmlDocument
    • Working with namespaces
    • Creating XML documents
    • Modifying element and attribute values
    • Adding elements
    • Removing elements and attributes
    • Copying nodes between documents
    • Schema validation
    • Infer a schema
  • System.Xml.Linq
    • Opening documents
    • Selecting nodes
    • Creating documents
    • Working with namespaces
    • Modifying element and attribute values
    • Adding nodes
    • Removing nodes
    • Schema validation
  • JSON
    • ConvertTo-Json
      • EnumsAsStrings
      • AsArray
      • EscapeHandling
    • ConvertFrom-Json
      • AsHashtable
      • NoEnumerate
  • Summary
• Web Requests and Web Services
  • Technical requirements
  • Web requests
    • HTTP methods
    • HTTPS
    • Bypassing SSL errors in Windows PowerShell
    • Capturing SSL errors
  • Working with REST
    • Invoke-RestMethod
    • Simple requests
    • Requests with arguments
    • Working with paging
    • Working with authentication
    • Using basic authentication
    • OAuth
      • Creating an application
      • Getting an authorization code
      • OAuth browser issues
      • Requesting an access token
      • Using a token
  • Working with SOAP
    • Finding a SOAP service
    • SOAP in Windows PowerShell
      • New-WebServiceProxy
      • Methods
      • Methods and enumerations
      • Methods and SOAP objects
      • Overlapping services
    • SOAP in PowerShell 7
      • Getting the WSDL document
      • Discovering methods and enumerations
      • Running methods
  • Summary
• Remoting and Remote Management
  • Technical requirements
  • WS-Management
    • Enabling remoting
    • Get-WSManInstance
    • The WSMan drive
    • Remoting and SSL
      • Set-WSManQuickConfig
    • Remoting and permissions
      • Remoting permissions GUI
      • Remoting permissions by script
    • User Account Control
    • Trusted hosts
  • PSSessions
    • New-PSSession
    • Get-PSSession
    • Invoke-Command
      • Local functions and remote sessions
      • Using splatting with ArgumentList
      • The AsJob parameter
      • Disconnected sessions
      • The using variable scope
    • The Enter-PSSession command
    • Import-PSSession
    • Export-PSSession
    • Copying items between sessions
  • Remoting on Linux
  • Remoting over SSH
    • Connecting from Windows to Linux
    • Connecting from Linux to Windows
  • The double-hop problem
    • CredSSP
    • Passing credentials
  • CIM sessions
    • New-CimSession
    • Get-CimSession
    • Using CIM sessions
  • Just Enough Administration
    • Session configuration
    • Role capabilities
  • Summary
• Asynchronous Processing
  • Working with jobs
    • The Start-Job, Get-Job, and Remove-Job commands
    • The Receive-Job command
    • The Wait-Job command
    • Jobs and the using scope modifier
    • The background operator
    • The ThreadJob module
    • Batching jobs
  • Reacting to events
    • The Register-ObjectEvent and *-Event commands
    • The Get-EventSubscriber and Unregister-Event commands
    • The Action, Event, EventArgs, and MessageData parameters
  • Using runspaces and runspace pools
    • Creating a PowerShell instance
    • The Invoke and BeginInvoke methods
    • The EndInvoke method and the PSDataCollection object
    • Running multiple instances
    • Using the RunspacePool object
    • About the InitialSessionState object
      • Adding modules and snap-ins
      • Adding variables
      • Adding functions
    • Using the InitialSessionState and RunspacePool objects
    • Using Runspace-synchronized objects
  • Summary
• Graphical User Interfaces
  • About Windows Presentation Foundation (WPF)
  • Designing a UI
  • About XAML
  • Displaying the UI
  • Layout
    • Using the Grid control
    • Using the StackPanel control
    • Using the DockPanel control
    • About Margin and Padding
  • Naming and locating elements
  • Handling events
    • Buttons and the Click event
    • ComboBox and SelectionChanged
    • Adding elements programmatically
    • Sorting a ListView
  • Responsive interfaces
    • Import-Xaml and Runspace support
    • Using the Dispatcher
  • Summary
• Scripts, Functions, and Script Blocks
  • About style
  • Capabilities of scripts, functions, and script blocks
    • Scripts and using statements
    • Scripts and Requires
    • Nesting functions
    • Script blocks and closures
  • Parameters and the param block
    • Parameter types
    • Default values
    • Cross-referencing parameters
  • The CmdletBinding attribute
    • Common parameters
    • CmdletBinding properties
    • ShouldProcess and ShouldContinue
      • ShouldProcess
      • ShouldContinue
  • The Alias attribute
  • begin, process, end, and cleanup
    • begin
    • process
    • end
    • cleanup
    • Named blocks and return
  • Managing output
    • The Out-Null command
    • Assigning to null
    • Redirecting to null
    • Casting to Void
  • Working with long lines
    • Line break after a pipe
    • Line break after an operator
    • Using the array operator to break up lines
  • Comment-based help
    • Parameter help
    • Examples
  • Summary
• Parameters, Validation, and Dynamic Parameters
  • The Parameter attribute
    • Position and positional binding
    • The DontShow property
    • The ValueFromRemainingArguments property
    • The HelpMessage property
  • Validating input
    • The PSTypeName attribute
    • Validation attributes
      • The ValidateNotNull attribute
      • The ValidateNotNullOrEmpty attribute
      • The ValidateCount attribute
      • The ValidateDrive attribute
      • The ValidateUserDrive attribute
      • The ValidateLength attribute
      • The ValidatePattern attribute
      • The ValidateRange attribute
      • The ValidateScript attribute
      • The ValidateSet attribute
    • The Allow attributes
      • The AllowNull attribute
      • The AllowEmptyString attribute
      • The AllowEmptyCollection attribute
    • PSReference parameters
  • Pipeline input
    • About ValueFromPipeline
    • Accepting null input
    • Input object types
    • Using ValueFromPipeline for multiple parameters
    • Using PSTypeName
    • About ValueFromPipelineByPropertyName
    • ValueFromPipelineByPropertyName and parameter aliases
  • Defining parameter sets
  • Argument completers
    • The ArgumentCompleter attribute
    • Using Register-ArgumentCompleter
    • Listing registered argument completers
  • Dynamic parameters
    • Creating a RuntimeDefinedParameter object
    • Using RuntimeDefinedParameterDictionary
    • Using dynamic parameters
    • Conditional parameters
  • Summary
• Classes and Enumerations
  • Defining an enumeration
    • Enum and underlying types
    • Automatic value assignment
    • Enum or ValidateSet
    • The Flags attribute
    • Using enumerations to convert a value
  • Creating a class
    • Properties
    • Constructors
    • Methods
    • The Hidden modifier
    • The Static modifier
    • Inheritance
      • Constructors and inheritance
      • Calling methods in a parent class
    • Working with interfaces
      • Implementing IComparable
      • Implementing IEquatable
    • Supporting casting
  • Classes for parameters
    • Argument-transformation attribute classes
    • Validation attribute classes
      • ValidateArgumentsAttribute
      • ValidateEnumeratedArgumentsAttribute
    • Classes for ValidateSet
  • Classes and DSC
    • Implementing Get
    • Implementing Set
    • Implementing Test
    • Using the resource
  • Summary
• Building Modules
  • Technical requirements
  • Creating a module
    • The root module
    • Export-ModuleMember
    • Module manifests
      • Test-ModuleManifest
      • Update-ModuleManifest
  • Publishing a module
    • Publishing and side-by-side versioning
  • Multi-file module layout
    • Dot sourcing module content
    • Merging module content
    • ModuleBuilder and DSC resources
  • Module scope
    • Accessing module scope
    • Modules, classes, and enumerations
  • Initializing and removing modules
    • The ScriptsToProcess property
    • The OnRemove event
  • Summary
• Testing
  • Technical requirements
  • Static analysis
    • PSScriptAnalyzer
      • Configurable rules
      • Suppressing rules
    • Using AST
      • Visualizing the AST
      • Searching the AST
    • Tokenizer
    • Custom script analyzer rules
      • Creating a custom rule
      • AST-based rules
      • Token-based rules
  • Testing with Pester
    • Testing methodologies
    • What to test
    • Describing tests
      • About the Describe and Context keywords
      • About the It keyword
    • Should and assertions
      • Testing for errors
    • Iteration with Pester
      • Using the TestCases parameter
      • Using the ForEach parameter
    • Conditional testing
      • Using Set-ItResult
      • Using Skip
    • Pester phases
    • Before and After blocks
    • Mocking commands
      • Parameter filtering
      • Overriding mocks
      • Mocking non-local commands
    • Mocking objects
      • Adding methods to PSCustomObject
      • Disarming .NET types
      • Mocking CIM objects
    • InModuleScope
      • Pester in scripts
  • Summary
• Error Handling
  • Error types
    • Non-terminating errors
    • Terminating errors
  • Error actions
    • About Get-Error
  • Raising errors
    • Error records
    • Raising non-terminating errors
      • Using the WriteError method
    • Raising terminating errors
      • Using the ThrowTerminatingError method
  • Catching errors
    • ErrorVariable
    • try, catch, and finally
    • Rethrowing errors
    • Inconsistent error handling
    • throw and ErrorAction
    • Nesting try, catch, and finally
    • About trap
      • Using trap
      • trap, scope, and continue
  • Summary
• Debugging and Troubleshooting
  • Common problems
    • Dash characters
    • Operator usage
      • Assignment instead of equality
      • -or instead of -and
      • Negated array comparisons
    • Use of named blocks
      • Code outside of a named block
      • Pipeline without process
    • Problems with variables
      • About strict mode
      • Variables and types
      • Types and reserved variables
  • Debugging in the console
    • Setting a command breakpoint
    • Using variable breakpoints
    • Setting a line breakpoint
  • Debugging in Visual Studio Code
    • Using the debugger
    • Viewing the CALL STACK
    • Using launch configurations
    • Using WATCH
  • Summary
• Other Books You May Enjoy
• Index

pokaż cały spis treści

ukryj recenzje