Powershell

Datum	Problem	Lösung
12.7.13	Im Script- Editor fehlen plötzlich Menü und Toolbar.	Script- Editor schließen Mit Kommandozeile in das Verzeichnis c:\>Users\<Benutzername>\AppData\Roaming\Quest Software\Power GUI wechseln. In diesem die Datei löschen BarManagerLayoutFile.xml Script Editor erneut starten. BarManagerLayoutFile.xml wird neu erstellt und Menu+ Toolbar sind wieder da.

Dokumentation

Benutzerhandbuch der Powershell: http://technet.microsoft.com/de-de/library/bb978526.aspx
Alle Cmdlets: http://technet.microsoft.com/en-us/library/hh848794.aspx
Wmi- Referenz: http://msdn.microsoft.com/en-us/library/windows/desktop/aa394572(v=vs.85).aspx
Infos zu Netzwerkkarten abrufen: http://msdn.microsoft.com/en-us/library/windows/desktop/aa394595(v=vs.85).aspx

Die Powershell- Skriptdatei

PS – Programme werden in Unicodedateien notiert. Diese erhalten einen Namen nach dem Schema dateiname.ps1. Die Datei enthält:

Kommentare (werden durch einen # eingeleitet)

Deklarationen von Variablen und Funktionen

PS- Anweisungen (cmdlet's, Aliase)

Beispiel:

# 18.16.2013, Martin Korneffel
# Kopiert alle NuGet- Pakete in der Projektmappe zum zentralen Paketordner
Get-ChildItem -Path c:\trac\projekt\MkoIT\WocServer2012  -Recurse | Where-Object{$_.Name -like "*.nupkg"} | Copy-Item -Destination c:\trac\NuGet\Packages 

# Ende

Grundlagen

Commandlets

Die Befehle der Powershell werden Commandlets (kurz: CmdLet) genannt. Sie haben folgenden grundlegenden Aufbau:

<Verb>-<Substantiv> [{-<Parameter>}]

Der Name eines Commandlets besteht aus zwei Teilen: dem Verb und dem Substantiv.

Mit dem Verb wird die auszuführende Aktion ausgewählt. Das Substantiv bezeichnet das Objekt, auf dem die Aktion auszuführen ist.

Parameternamen beginnen immer mit einem -. Diese werden auch als Schlüssel (Key) bezeichnet.

Ein Beispiel ist das lesen aller Einträge im Dateiverzeichnis c:\Windows:

Get-ChildItem -Path c:\Windows

Die Groß/Kleinschreibung ist irrelevant.

Alle verfügbaren Befehle auflisten

Eine Liste aller Powershell- Befehle und Funtionen liefert

Get-Command

Die Liste besteht aus Zeilen mit folgenden Spalten:

CommandType, Name, Definition

Unter CommandType werden neben CmdLet auch Alias, Function und Application aufgelistet. Sollen nur Commandlets aufgeführt werden, dann:

Get-Command -CommandType CmdLet

Aus der Powershell heraus können auch alte CMD.EXE und Unix Shell Kommandos abgesetzt werden. Diese wurden dabei durch Alias- Namen auf PS- Cmdlets abgebildet. Eine Übersicht über alle Befehle aus den klassischen Kommandozeilen liefert folglich

Get-Command -CommandType Alias

Allgemeine Parameter

Für alle Commandlets ist die Implementierung eines Satzes sog. allgemeiner Parameter vorgeschrieben. Im Folgenden eine Auflistung:

Parameter	Bedeutung
WhatIf
Confirm
Verbose
Debug
Warn
ErrorAction
ErrorVariable
OutVariable
OutBuffer

N Kommandos in einer Kommandozeile

Im Grundmodus geht der PS- Interpreter von einer Anweisung pro Zeile aus. Das Zeilenumbruchzeichen schließt die Anweisung ab.

Sollen N Powershell – Anweisungen in einer Zeile notiert werden, dann müssen die Anweisungen jeweils durch ein Semikolon getrennt werden:

<Anweisung 1>; <Anweisung 2>; … ; <Anweisung N>

Folgendes Beispiel Listet in einer Kommandozeile alle Elemente des aktuellen Arbeitsverzeichnisses auf, wechselt das Arbeitsverzeichnis auf c:\windows, Listet erneut alle Elemente vom Arbeitsverzeichnis auf und wechselt schließlich in das ursprüngliche Arbeitsverzeichnis zurück:

Get-ChildItem; Push-Location; Set-Location -Path "c:\Windows"; Get-ChildItem; Pop-Location; Get-ChildItem

Ein Kommando auf mehrere Zeilen verteilen

Alternativ zu N- Kommandos in einer Zeile kann auch der Wunsch bestehen, ein langes Kommando auf mehrere Zeilen zu verteilen. Dies gelingt mit dem Backtick `.

Beispiel: Ursprüngliche lange Anweisung:

Get-ChildItem c:\Windows | Get-MEmber | Out-Host

Durch Backtick auf mehrere Zeilen umgebrochene Anweisung:

Get-ChildItem c:\Windows |`
Get-MEmber |`
Out-Host

Literale

Zahlenwerte

Festkommawerte (Int32 etc.) Dezimal	1234
Festkommawerte, Hexadezimal	0x1AD
Gleitkommawerte (Single, Double)	1234.0
Gleitkommawerte - Exponentialschreibweise	1.234E+003

Wahrheitswerte

Wahrheitswerte haben in der Powershell streng definierten Literale. Es gelten folgende Konventionen:

FALSE	$FALSE, 0, ""
TRUE	$TRUE, !=0, "..."

Siehe auch: http://blogs.msdn.com/b/powershell/archive/2006/12/24/boolean-values-and-operators.aspx

Escapesequenzen

Eine Escapesequenz setzt sich aus einem Backtick` und einem Buchstaben zusammen. Durch Escapesequenzen werden Zeichen dargestellt, die z.B. Steuerzeichen sind und in einer Zeichenkette eingebettet werden sollen.

Tabulator	`t
New Line	`n
Wagenrücklauf	`r
Alert oder Glockenton	`a
Backspace	`b
Terminierende 0 (Zero)	`0
Apostroph	`'
Anführungszeichen	`"

Variablen

Ergebnisse von Berechnungen und Abfragen können in Variablen abgelegt werden. Eine Variable wird durch eine Zuweisung deklariert und definiert:

$<Variablenname> = <Wert oder Objektreferenz>

Dabei wird der Wert oder die Objektreferenz auf der rechten Seite in die Variable auf der linken Seite kopiert.

Variablen- Namen beginnen stets mit einem $:

$Pi = 3.14
$Text = "Hallo Welt"
$heuteUndJetzt = Get-Date

Typisierte Variablen

Werden Variablen durch Zuweisen eines Wertes an einen Namen deklariert, dann handelt es sich um untypisierte Variablen. Sie passen ihren Typ den zugewiesenen Werten an:

$Pi = 3.14;
Write-Host '$Pi= ' $Pi

# Typ einer untypisierten Variable passt sich beim Zuweisen an
$Pi = "3,14dbl"
Write-Host '$Pi= ' $Pi

Diese Verhalten ist Quelle vielfältiger Programmierfehler. Es kann durch eine Variablendeklaration mit Datentyp abgeschaltet werden. Der Datentyp wird dabei als Attribut bei der ersten Zuweisung eines Wertes an die Variable vorangestellt:

[Datentypattribut]$<Variablenname> = <Wert oder Objektreferenz>

Beispiel:

# Variabledeklaration mit Datentyp
[double]$dblPi = 3.14
Write-Host '$dblPi= ' $dblPi

# Typ einer typisierten Variable erlaubt keine Zuweisungen von Werten mit inkompatiblen Typ
$dblPi = "3,14dbl"

Datentypen

Da PS ,auf .NET aufbaut, können alle aus .NET bekannten Datentypen eingesetzt werden. Beispiel:

[String]$strHalloWelt = "Hallo typisierte Welt"

[DateTime]$datHeuteUndJetzt = Get-Date

$ÜberÜbermorgen = $datHeuteUndJetzt.AddDays(3)

Write-Host $ÜberÜbermorgen.DayOfWeek

Arrays

Stellt das Ergebnis einer Berechnung oder der Rückgabewert eines CmdLets eine Liste dar, dann wird diese in PS als Array dargestellt. Arrays können an Variablen zugewiesen werden:

$C_Windows = Get-ChildItem -Path c:\Windows

Arrays können direkt mittels des @- Operators erzeugt werden:

$Primzahlen = @(2, 3, 5, 7, 11, 13, 17, 19)

Eine weitere Möglichkeit, speziell ein Array aus Integern zu erzeugen, liefert der Aufzählungsoperator .. :

$Zahle1bis100 = 1..100

Zugriff auf einzelne Einträge gelingt mit dem Indexzugriffoperator[..]:

$einePrimzahl = $Primzahlen[2]

Verarbeiten werden können Arrays z.B. mit der ForEach- Funktion :

# Folgendes Skript quadriert alle Primzahlen und gibt die Quadrate auf der Kommandozeile aus
?Primzahlen | ForEach{Write-Host $_*$_}

Hashtables

In einem Array wird ist jedem Eintrag ein nummerischer Index zugeordnet. Verallgemeinert muss der Index nicht nummerisch sein. Er wird dann als Schlüssel bezeichnet, dem ein Wert zugeordnet ist. Eine eindeutige Abbildung einer endlichen Menge von Schlüsseln auf eine endliche Menge von Speicherplätzen wird Hashtable genannt.

Hashtables können wie Arrays direkt mittels @- Operator gebildet werden.

#Hashtables 
$TelBuch = @{Anton=4711; Berta=9815; Cäsar=6969}
$TelNrBerta = $TelBuch["Berta"]

Operatoren

Symbol	Bedeutung	Beispiel
=	Zuweisungsoperator	$A = 99
-eq	Gleichheitsoperator	Get-Services \| Where-Object{$_.Status -eq "Running"}
-ne	Ungleich
-gt	Größer als
-ge	Größer gleich
-lt	Kleiner als
-le	Kleiner gleich
+	Addition oder Stringverkettung
-	Subtraktion
*	Multiplikation
/	Division
%	Modulo- Operator (Rest der ganzzahligen Division)
-And	Logisches UND
-Or	Logisches Oder
-Not	Logisches Nicht
!	Logisches Nicht
-BAnd	Binäres UND
-BOr	Binäres ODER
-BNot	Binäres Nicht
-Contains	Liefert true, wenn ein Objekt in einer Liste enthalten ist
-NotContains	Liefert true, wenn ein Objekt in einer Liste nicht enthalten ist
-Like	Liefert true, wenn ein String mit einem Wortmuster, das Wildcards einsetzt (*, ?) übereinstimmt
-NotLike	Liefert true, wenn ein String mit einem Wortmuster, das Wildcards nicht übereinstimmt
-Match	Liefert true, wenn ein String mit einem Wortmuster, das einem regulären Ausdruck entspricht, übereinstimmt
-NotMatch	Liefert true, wenn ein String mit einem Wortmuster, das einem regulären Ausdruck entspricht, nicht übereinstimmt
a..b	Bereichsoperator: Erzeugt eine Liste von zwischen a und b	$ZahlenVon1bis100 = 1..100

Objektorientierung

Mittels Scripts wird durch PS das Betriebssystem gesteuert. Dieses stellt sich aus der Perspektive von PS als Menge von .NET Objekten dar.

Im folgenden Beispiel wird auf das Anwendungsprotokoll vom Betriebssystem zugegriffen. Dabei wird ein Array aus .NET System.Diagnostics.EventLogEntry- Objekten aufgebaut. Auf die Eigenschaften kann mittels Zugriffsoperatoren, wie aus .NET- Sprachen bekannt, zugegriffen werden:

# Zugriff auf das Anwendungsprotokoll von Windows
$AppLog = Get-EventLog -LogName "Application" -After 1.6.2013

# Alle Ausgaben im Powershell- Konsolefenster löschen
Clear-Host

# Meldung in auf der Konsole ausgeben
Write-Host "Anwendungslog"

# Anzahl der eingelesenen Einträge ausgeben (Objektorientierng !)
Write-Host "- Anz Einträge: " $AppLog.Count

# Zugriff auf ersten Eintrag (Zugriff auf Arrayelement !)
$ersterEintrag = $AppLog[0]

Write-Host "Erster Eintrag"

# Datentypbezeichner des ersten Eintrages abrufen (.Net System.Diagnostics.EventLogEntry !)
Write-Host "- Typname   : " $ersterEintrag.ToString()

# Zugriff auf die Eigenschaften (Objektorientierng !)
Write-Host "- erstellt    : " $ersterEintrag.TimeGenerated.ToString()
Write-Host "- geschrieben : " $ersterEintrag.TimeWritten.ToString()
Write-Host "- Category    : " $ersterEintrag.Category
Write-Host "- EntryType   : " $ersterEintrag.EntryType.ToString()
Write-Host "- Message     : " $ersterEintrag.Message
Write-Host "Ende"

Typ und Eigenschaften von Ergebnismengen bestimmen

Welchen .NET Typ die Ergebnisse von PS- Kommandos besitzen und welche Member diese aufweisen kann mit dem Kommando

Get-Member

bestimmt werden.

Im Folgenden Beispiel werden Datentyp der Objekte bestimmt, die der Zugriff auf die Dateisystemeinträge unter c:\windows liefert:

Get-ChildItem c:\Windows |  Get-Member

Zugriff auf Klassen aus .NET Assemblies

Eine für Programmierer hochinteressante Möglichkeit der Zugriff auf Klassen aus beliebigen- , und damit auch selbstgeschriebenen Assemblies. Dies gelingt mit der Anweisung

Add-Type -Path <Dateiname der Assembly>

Nachdem eine Add-Type Anweisung ausgeführt wurde, ist die Assembly in der Powershell eingebunden. Beispiel: Anwendungsbibliothek mit diversen Algorithmen laden:

# Assembly, die z.B. einen Implementierung der Prizahlsuche enthält
Add-Type -Path "c:\trac\projekt\MkoIT\WocServer2012\mko.Algo\bin\Debug\mko.Algo.dll"

Für Klassen aus der .NET Framework- Bibliothek ist des Add-Type schon automatisch beim Start der PS ausgeführt worden- auf ein explizites Einbinden von System.dll kann verzichtet werden.

Zugriff auf statische Klassenmember

Statische Klassenmember können nun direkt aufgerufen werden. Der Klassenname ist dabei in eckige Klammern zu setzen. Die statischen Eigenschaften sind über den ::- Operator erreichbar. Im Folgenden Beispiel wird die Methode GetDirectory aus System.IO.Directory aufgerufen:

$dir = [System.IO.Directory]::GetDirectories('c:\Windows')

In diesem Beispiel werden Implementierungen der Primzahlsuche aus einer selbstgeschriebenen Assembly ,aufgerufen:

Clear-Host

# Assembly, die z.B. einen Implementierung der Prizahlsuche enthält
Add-Type -Path "c:\trac\projekt\MkoIT\WocServer2012\mko.Algo\bin\Debug\mko.Algo.dll"

# Start der statischen Methode für die Primzahlsuche im Bereich 1 bis 100. Das Ergebnis ist eine
# Liste der Primzahlen
$primlist = [mko.Algo.NumberTheory.PrimeFactors]::scan(1, 100)

# Start der statischen Methode für die Primzahlsuche im Bereich 1 bis 1 Mio. Das Ergebnis ist eine
# Liste der Primzahlen. Die Berechnung wird auf mehrere Threads verteilt
$primlist2 = [mko.Algo.NumberTheory.PrimeFactors]::scanParallel(1,1000000, 1)

$primlist | Out-Host
$primlist2 | Out-Host -Paging

Objekt einer .NET Klasse instanziieren

Die Instanziierung von Objekten aus Assemblies setzt das erfolgreich Einbinden dieser voraus. Anschließend muss mit dem New-Object- CmdLet ein Konstruktor der Klasse aufgerufen werden:

$ObjRef = New-Object – Typename <vollqualifizierter Name der Klasse>

Im folgenden Beispiel wird ein Datumsobjekt der Klasse System.DateTime mit einen Konstruktor, der Jahr, Monat, Tag als Parameter erwartet:

Clear-Host
# Instanziierung eines Datums- Objektes aus dem Namespace System
$datum = New-Object -TypeName System.DateTime -ArgumentList 2013, 1, 5
$datum | Select-Object Day, Month, Year

Orthogonalität und Pipe- Operator

Orthogonalität ist ein Qualitätsmerkmal für Softwarebibliotheken. Eine Bibliothek ist orthogonal, wenn sie einen minimalen Satz elementarer Grundfunktionen anbietet, aus denen die geforderte Funktionalität durch Kombination der Grundfunktionen entsteht.

Z.B. können alle Problemlösungen der Arithmetik durch Kombinationen der vier Grundrechenarten +, -, * und / formuliert werden:

  π = 4*(1 – 1/3 + 1/5 – 1/7 + 1/9 -... ± 1/(2*n-1))  oder sin(x) = x – x*x*x/1*2*3 + x*x*x*x*x/1*2*3*4*5 – x*x*x*x*x*x*x/1*2*3*4*5*6*7+...

Analog ist die Powershell entworfen worden. Es gibt Kommandos zum

Erzeugen von Objekten (z.B. Get-ChildItem -Path "...")

Filtern von Objektmengen (z.B. Where{$_.Extension -eq "..."})

Sortieren von Objektmengen (z.B. Sort-Object -Property <Propertyname>

Projektion von Eingaben auf Ausgaben (z.B. Select-Object -Property <selectedPropertyname>, …

Ausgabe auf einem Medium (z.B. Out-Host -Paging)

...

Jedes dieser Kommandos dient zum Lösen einer Aufgabe aus einer Menge spezieller Aufgaben. Die Aufgabenstellungen für die verschiedenen Kommandos überschneiden sich dabei nicht (disjunkte Mengen spezieller Aufgaben).

Die Kombination der arithmetischen Grundfunktionen wird durch Prioritäten und Klammerung gesteuert.

X = 3*(5 + 7)/2 → Mov(X, Mul(3, Div(Add(5, 7), 2)))

Binärer Pipe- Operator A | B zur Funktionsverkettung

In der Powershell erfolgt die Kombination von Kommandos durch den binären Pipe- Operator A | B. Dabei wird A zuerst berechnet. Das Ergebnis ist die Eingabe von B. Das Entspricht der Verkettung oder Hintereinanderschaltung von Funktionen in der Mathematik:

A | B → B(A())

Beispiel:

Clear-Host
# Liefert alle Einträge unter Path als System.IO.FileInfo- Objekte
$Files = Get-ChildItem -Path 'c:\trac\projekt\lernen-dot-net\Bildergalerie' -Recurse 

# Filtert alle Objekte, deren Eigenschaft .Extension == ".jpg" ist
$Jpgs = $Files | Where {$_.extension -eq ".jpg"}

# Liefert 1. Eintrag aus gefilterter Liste
$First = $Jpgs[0]

# Sortiert Liste bezüglich FileInfo- Eigenschaft Name
$Sortet = $Jpgs | Sort-Object -Property Directory, Name

# Projektion der Fileinfo- Objekte auf new{Name = $_.Name, Directory=$_.Directory}
$Selected = $Sortet | Select-Object -Property Name, Directory

# Seitenweise Ausgabe des Ergebnisses
$Selected | Out-Host -Paging

Pipe als Objektdatenstrom

Werden Kommandos mittels Pipe- Operator hintereinandergeschaltet, dann entsteht aus technischer Sicht ein System aus Datenquelle und Datensenke, die durch einen Datenstrom, Pipe genannt, verbunden sind. Dies erweitert die Funktionalität von Datensenken, indem sie nicht nur ein Element der Eingabe auf eine Ausgabe abbilden, worauf ein rein mathematisch begründeter Pipeoperator beschränkt wäre. Auch das sequentielle Einlesen mehrere Eingaben in der Datensenke zur Berechnung einer Ausgabe ist möglich, wie folgende Abbildung für das Kommando

Get-ChildItem -Path C:\... -Recurse | Out-Host -Paging

zeigt:

Funktionsblöcke

Wiederholende Abschnitte in einem Script können in einen parametrierbaren Funktionsblock ausgelagert werden. In der einfachsten Form ähneln die Funktionsblöcken denen in JavaScript. Sie beginnen mit den Schlüsselwort function, dem der Name der Funktion und die Parameterliste folgt. Daran schließt sich dann in geschweiften Klammern die ausgelagerte Anweisungsliste an:

# Funktion in klassischer Form deklarieren
function Add($A, $B) {
        return $A + $B
}

# Achtung: Beim Funktionsaufruf dürfen keine runden Klammern eingesetzt werden,
# da sonst ein Array mit den Elementen 2 und 3 übergeben wird !
$sum = Add 2 3
$sum | Out-Host

In der klassischen Form ist eine Auszeichnung der Funktionsparameter mit Datentyp - Attributen nicht möglich. Stattdessen können Funktionsparameter in einer param- Anweisung mit Datentypen ausgezeichnet werden, die die erste Anweisung im Funktionsblock sein muss:

# Funktion in Powershell- spezifischer Form deklarieren. Die Parameter 
# können mit Attributen ausgezeichnet werden wie Datentyp
function Add2{
        param([double]$A, [double]$B)
        return $A + $B
}

[double]$dblSum = Add2 2.1 3.2
$dblSum | Out-Host

Scriptblöcke: Lambda- Ausdrücke in der Powershell

Neben Funktionsblöcken kann in PS Funktionalität in einer noch flexibleren Form verpackt werden: den Scriptblöcken. Sie erfüllen in PS die gleichen Aufgaben wie Lambdaausdrücke in C#. Scriptblöcke sind anonyme (namenlose) Funktionsblöcke und haben folglich keinen Funktionskopf. Scriptblöcke können Variablen zugewiesen, oder als Parameter übergeben werden.

# Definition eines Lambda- Ausdruckes. Wird auch als Scriptblock bezeichnet
$LambdaAdd = {param([double]$x, [double]$y) $x + $y}

Ein Lambdaausdruck kann auf einen Parametersatz angewendet werden mittels des Aufrufoperators &:

# Lambda-Asudruck auf Werte Anwenden mittels Aufrufoperator &
$res = &$LambdaAdd 3.14 2.72
$res | Out-Host

Externe Programme mittels Aufrufoperator ausführen

Externe Programme wie z.B. das .NET Package- Programm NuGet.exe können analog den Lambdaausdrücken mittels Aufrufoperator & gestartet werden:

# Externes Programm analog einem Lambdaausdruck einer Variable zuweisen
$Kommando = 'c:\trac\NuGet\NuGet.exe'

# Programm mittels Aufrufoperator starten
&$Kommando Help pack | Out-Host

Verwaltung von Ressourcen als Laufwerke

Ein Organisationsmittel in PS ist das Laufwerk. Im Windows- Betriebssystem ist das Laufwerk ein Synonym für die mit einem Buchstaben benannte Partition einer Festplatte. In PS wird dieser Begriff erweitert, indem mit Laufwerken die Menge aller von PS zu verwaltenden Objekte (also auch Umgebungsvariablen, AD- und FTP- Ressourcen) partitioniert werden.

Eine Übersicht über die von PS bereits eingerichteten Laufwerke liefert folgendes CmdLet:

Get-PSDrive

Ein Beispiel für die Erweiterung des Laufwerksbegriff in PS ist das Laufwerk der Zertifikate:

Get-ChildItem -Path Cert:\ | Out-Host -Paging

Write-Host "Current User"
Get-ChildItem -Path Cert:\CurrentUser | Out-Host -Paging

Write-Host "Current User\Root"
Get-ChildItem -Path Cert:\CurrentUser\Root | Get-Member #| Out-Host -Paging

Im folgenden die Analyse weiterer Laufwerke:

# PS- Laufwerke: Partitionen der Systemressourcen
Clear-Host
# Alle Einträge unter c:
Write-Host "c: ----------------------------------------"
Get-ChildItem c: | ForEach{Write-Host $_.Name}

# Alle Variablen 
Write-Host "Variablen: ----------------------------------------"
Get-ChildItem variable: | ForEach{Write-Host $_.Name}

# Alle Umgebungsvariablen
Write-Host "Umgebungsvariablen: ----------------------------------------"
Get-ChildItem env: | ForEach{Write-Host $_.Name}

# Alle Variablen 
Write-Host "Alle Registryschlüssel der lokalen Maschine: ----------------------------------------"
Get-ChildItem HKLM:  | ForEach{Write-Host $_.Name}

Write-Host "Alle Registryschlüssel des angemeldeten Users: ----------------------------------------"
Get-ChildItem HKCU:  | ForEach{Write-Host $_.Name}

Arbeitsverzeichnis bestimmen oder setzen

Jedes Script läuft in einem Kontext, der für die Laufwerke jeweils ein Arbeitsverzeichnis definiert (.\). Das Arbeitsverzeichnis kann mit dem CmdLet

Get-Location

abgerufen, und mit dem CmdLet

Set-Location

gesetzt werden.

Verzeichnis und Name des aktuell ausgeführten Scriptes bestimmen

Möchte man aus einem Script z.B. auf Konfigurationsdateien zugreifen, die im selben Verzeichnis wie die Scriptdatei gespeichert sind, dann kann der voll qualifizierte Scriptname bestimmt werden über:

$Scriptfilename = $MyInvocation.MyCommand.Path

Quoting

Befinden sich innerhalb von Zeichenketten- Konstanten ausführbare PS- Kommandos, dann werden diese ausgewertet. Das Verhalten kann durch Quoting unterdrückt werden:

Write-Output "Aktuelle Kultur: $PSCulture" # Ausgabe: Aktuelle Kultur: de-DE
Write-Output 'Aktuelle Kultur: $PSCulture' # Ausgabe: Aktuelle Kultur: $PSCulture

Spezielles

FTP-Zugriff

http://gallery.technet.microsoft.com/scriptcenter/PowerShell-FTP-Client-db6fe0cb

Webservice konsummieren

New-WebServiceProxy