Archiv des Autors: PemoAdmin

Module in einer Remote-Session global importieren am Beispiel von Office 365/Exchange Online

Der Zugriff auf Exchange bzw. Exchange Online (Office 365) erfolgt im Rahmen einer Remote-Session. Im ersten Schritt wird die Remote-Session angelegt, im zweiten Schritt wird ein Modul im Rahmen der Remote-Session lokal importiert, so dass alle Cmdlets aus dem Modul lokal als (Proxy-) Functions zur Verfügung stehen.

Hier ein kleines Beispiel.

$NewSession = New-PSSession -ConfigurationName Microsoft.Exchange `
  -ConnectionUri https://outlook.office365.com/powershell-liveid/ `
  -Credential $O365Cred -Authentication Basic -AllowRedirection -ErrorAction Stop
  Import-PSSession $NewSession -Verbose -DisableNameChecking -AllowClobber

$NewSession = New-PSSession -ConfigurationName Microsoft.Exchange `

-ConnectionUri https://outlook.office365.com/powershell-liveid/ `

-Credential $O365Cred -Authentication Basic -AllowRedirection -ErrorAction Stop

Import-PSSession $NewSession -Verbose -DisableNameChecking -AllowClobber

Das ist alles in der offiziellen PowerShell/Office 365-Dokumentation ausführlich dokumentiert, z.B.

https://docs.microsoft.com/de-de/office365/enterprise/powershell/manage-office-365-with-office-365-powershell

Was aber, wenn man das Importieren des Remote-Moduls in ein Modul auslagern möchte? Auf einmal steht das Remote-Modul außerhalb des Moduls nicht mehr zur Verfügung.

Ich muss zugegeben, dass ich auf die Lösung nicht auf Anhieb gekommen bin (oft bin ich auch zu bequem, um es wirklich zu probieren). Sie besteht darin, dass temporäre Modul per Import-Module mit dem Parameter Global oder Scope global zu importieren. Dadurch steht es anschließend auch außerhalb des angelegten Moduls zur Verfügung.

$M365 = Import-PSSession $NewSession -Verbose -DisableNameChecking -AllowClobber 
Import-Module -ModuleInfo $M365 -Scope Global -DisableNameChecking

1 2	$M365 = Import-PSSession $NewSession -Verbose -DisableNameChecking -AllowClobber Import-Module -ModuleInfo $M365 -Scope Global -DisableNameChecking

Kleine Tipps für Zwischendurch: Datumszeitangaben im UTC-Format konvertieren

Schreibe eine Antwort

Datumskonvertierungen sind ein Thema für sich, insbesondere, wenn Spezialitäten wie UTC-Zeitangaben (Universal Time Coordinate) wie „20181010T110000“ ins Spiel kommen. Solche Datumswerte kommen z.B. in Ics-Dateien vor, die als Einladung zu einem Meeting verschickt werden.

PowerShell ist dank dem .NET Framework-Unterbau sehr vielseitig was den Umgang mit Datumsformat angeht, man muss eventuell nur ein wenig suchen bzw. experimentierfreudig sein.

So hat es eine Weile gedauert bis ich herausgefunden hatte wie die obige Zeichenfolge in einen DateTime-Wert konvertiert wird:

[Datetime]::ParseExact("20181010T110000", "yyyyMMddTHHmmss", $null)

1	[Datetime]::ParseExact("20181010T110000", "yyyyMMddTHHmmss", $null)

Das Geheimnis besteht darin, dass die zweite Zeichenfolge den Aufbau der ersten Zeichenfolge so abbilden muss, dass ein gültiger Datumszeitwert resultiert.

Das „T“ stört natürlich ein wenig. Der vielseitige replace-Operator lässt es unaufällig verschwinden:

$UTCWert = "20181010T110000" -replace "T"
[Datetime]::ParseExact($UTCWert, "yyyyMMddHHmmss", $null)

1 2	$UTCWert = "20181010T110000" -replace "T" [Datetime]::ParseExact($UTCWert, "yyyyMMddHHmmss", $null)

Einen Access Token für Microsoft Graph erhalten

Schreibe eine Antwort

Mein neues Schwerpunktthema ist Office 365-Administration per PowerShell&Co und in diesem Themenkontext vor allem die reichhaltige Microsoft Graph-API.

Das für das Ausführen von Abfragen erforderliche Access Token zu erhalten ist nicht ganz so einfach. Das liegt weniger an der Technik, sondern eher daran, dass die Thematik (u.a. OAUth 2.0) ungewohnt ist und viele Wege nach Rom führen, von denen einige auch in Sackgassen führen.

Eine sehr gute Anleitung hat Microsoft Mitarbeiter Paul Kotylo in seinem Blog beschrieben:

https://blogs.technet.microsoft.com/cloudlojik/2018/06/29/connecting-to-microsoft-graph-with-a-native-app-using-powershell/

Wer die Schritte der Reihe nach ausführt (und keine Fehler macht) kommt zu einem Erfolg und kann Abfragen wie die folgende ausführen:

# Einfache Abfrage aller User
$ApiUri = "https://graph.microsoft.com/v1.0/users"

$Result = Invoke-RestMethod -Headers $Header -Uri $ApiUri -UseBasicParsing
$Result.Value

# Einfache Abfrage aller User

$ApiUri = "https://graph.microsoft.com/v1.0/users"

$Result = Invoke-RestMethod -Headers $Header -Uri $ApiUri -UseBasicParsing

$Result.Value

Die auf ODATA basierende Abfragesyntax wird hier beschrieben:

https://developer.microsoft.com/en-us/graph/docs/concepts/query_parameters

1	https://developer.microsoft.com/en-us/graph/docs/concepts/query_parameters

Ob eine Abfrage funktioniert hängt auch davon ab, ob für die App die erforderliche Berechtigung gesetzt wurde.

Ich werden das Thema in einigen Wochen an dieser Stelle ausführlicher mit einer Schritt für Schritt-Anleitung vorstellen.

Kleine Tipps für Zwischendurch: PowerShell Core-Module aus der PowerShell Gallery auflisten

Schreibe eine Antwort

PowerShell Core ist die Zukunft. Möglichst viele der Module, die Teil von Windows und Windows Server sind, sollen früher oder später auch für PowerShell Core verfügbar sein.

Modul-Autoren sollen im Modulmanifest den Eintrag CompatiblePSEditions verwenden und dort die Editionen „PSDesktop“ und „PSCore“ eintragen. Dieser Eintrag wird aber erst ab WMF 5.1 verstanden.

Aktuell ist es nicht ganz so einfach wie es sein könnte herauszufinden, ob ein Modul der PowerShell Gallery auch für PowerShell Core in Frage kommt. Diese Information verbirgt sich in der unscheinbaren Tags-Eigenschaft eines Modul.

In der PowerShell Dokumentation wird das Prinzip der Abfrage bereits ausführlich beschrieben:

https://docs.microsoft.com/en-us/powershell/gallery/how-to/finding-items/searching-by-psedition

Zwei kleine Beispiele sollen die Abfrage per Find-Module in der Praxis zeigen.

Find-Module -Tag "PSEdition_Core"  | Select Name, Tags

1	Find-Module -Tag "PSEdition_Core" \| Select Name, Tags

Etwas komfortabler ist der folgende Befehl, der zu allen Modulen der PowerShell Gallery die Editionen angibt, unter denen sie verwendet werden können.

Find-Module -Tag "PSEdition_Core"  | Select Name, @{n="Edition";e={ ([Regex]::Matches($_.Tags, "PSEdition_\w+")).Value -join ","}}

1	Find-Module -Tag "PSEdition_Core" \| Select Name, @{n="Edition";e={ ([Regex]::Matches($_.Tags, "PSEdition_\w+")).Value -join ","}}

Der folgende Befehl gruppiert die ganze Ausgabe nach der Eigenschaft Edition:

$Module = Find-Module -Tag "PSEdition_Core"  | Select Name, @{n="Edition";e={ ([Regex]::Matches($_.Tags, "PSEdition_\w+")).Value -join ","}}
$Module | Group-Object -Property Edition

1 2	$Module = Find-Module -Tag "PSEdition_Core" \| Select Name, @{n="Edition";e={ ([Regex]::Matches($_.Tags, "PSEdition_\w+")).Value -join ","}} $Module \| Group-Object -Property Edition

Wenn die Abfrage stimmt, sind von den über 3.200 Modulen der PowerShell Gallery nur etwas über 200 Module mit einem PSEdition-Information versehen. Und da man in die Tags-Eigenschaft alles eintragen kann, gibt es auch unterschiedliche Schreibweisen.

Wer bei den installierten Modulen die Edition abfragen möchte, verwendet dazu die CompatiblePSEditions-Eigenschaft:

Get-Module -ListAvailable | Select -Property Name, CompatiblePSEditions

1	Get-Module -ListAvailable \| Select -Property Name, CompatiblePSEditions

oder

Get-Module -ListAvailable | Group {$_.CompatiblePSEditions -join ","}

1	Get-Module -ListAvailable \| Group {$_.CompatiblePSEditions -join ","}

Wenn in der PowerShell-Konsole oder ISE nichts ausgegeben wird, liegt es an der PSModulePath-Umgebungsvariablen. Nur bei PowerShell Core ist das Verzeichnis c:\Program files\powershell\6\Modules mit dabei.

Die Beispiele zu meinem Vortrag auf der Basta! 2018

Schreibe eine Antwort

Die Basta! (der Name stand ursprünglich einmal für „Basic Tage“ – BASIC ist eine Programmiersprache, die vor allem in den 90er Jahren populär war – das Ausrufezeichen ist vermutlich aus Marketinggründen angehängt worden) ist zwar eine Entwicklerkonferenz, die zwei Mal im Jahr stattfindet (und das bereits seit über 20 Jahren), doch wie bei jeder Konferenz haben auch Randthemen ihren Platz.

Die Beispiele (in Gestalt einer Reihe von PowerShell-Skripten) gibt es unter dem folgenden Link:

Basta2018_PowerShellSkripte

Mehr zu dem Vortrag in Kürze (während ich diese Zeilen schreibe liegt er nämlich noch in der Zukunft und diese ist bekanntlich etwas schwierig vorauszusagen).

Convert a hashtable into its string representation

Schreibe eine Antwort

Recently I had to find a technique to update a module manitest file (psd1). Using the Update-ModuleManifest cmdlet is the official way to achieve this. Although using this command is really simple it completely overwrites the current psd1 file and inserts all the „junk“ that I want to keep out from that file.

Another approach is to load the psd1 file with the Import-LocalizedData cmdlet which results to a hashtable.

$Psd1Data = Import-LocalizedData -FileName Osmium.psd1

1	$Psd1Data = Import-LocalizedData -FileName Osmium.psd1

Updating single entries is easy:

$Psd1Data.PrivataData.PsData.ReleaseNotes = "Readmefirst.rtf"

1	$Psd1Data.PrivataData.PsData.ReleaseNotes = "Readmefirst.rtf"

But how do you turn the the whole hashtable with all its keys and values into a string again? Not so easy. Luckily I found an old blog entry by June Blender (when she was still working for Sapien Technologies):

https://www.sapien.com/blog/2014/10/21/a-better-tostring-method-for-hash-tables/

But June restricted her function to simple hashtables with no values that are hashtables themselves.

So I have extend her function so that it works also with hashtable that contains other hashtable values which is necessary to convert a hashtable that represents a psd1 file. Ny function calls itself recursively which which is not hard to accomplish in PowerShell. The difficult part can be to find an exit condition or threat the last value differently. For this reason I am not using foreach but the for command with an index variable to enumerate all the values. For the last value I add „}“ to complete the hashtable string.

As PowerShell expert Kirk Munro suggested in his comments to Junes blog post converting the hashtable to json might be a simpler solution. I have not tried this yet although it probably could have saved me a lot of typing and trying. But hey, why choosing a simple solution if you can spend a couple of hours fiddling with Powershell script code;)

<#
 .Synopsis
 Converts a hashtable into a string representation of all its values
#>
function Convert-HashtableToString
{
    param([System.Collections.Hashtable]$Hashtable, [Switch]$Recurse)
    # Add @{ only once to the text
    if (!$PSBoundParameters.ContainsKey("Recurse"))
    {
        $hashtext = "@{"
    }
    # cannot use foreach because I have to catch the last loop for adding }
    for($i=0;$i -lt $Hashtable.Keys.Count;$i++)
    {
        # get the current key
        $k = @($Hashtable.Keys)[$i]
        # get the current value
        $v = $Hashtable[$k]
        # check if value is a hashtable
        if ($v -is [System.Collections.Hashtable])
        {
            $hashtext += "$k=@{"
            # call function recursively
            $hashtext += Convert-HashToString -Hashtable $v -Recurse
            $hashtext += ";"
        }
        # check if value is an array
        elseif ($v -is [System.Array])
        {
            $hashtext += "$k=@("
            $hashtext += $v.ForEach{"'$_'"} -join ","
            $hashtext += ");"
        }
        else
        {
            $hashtext += $k + "=" + "`"$v`"" + ";"
        }
        # if last loop add } to the output
        if ($i -eq $Hashtable.Keys.Count -1 )
        {
            $hashtext += "}"
        }
    }
    # return the text - no need for a return statement
    $hashtext
}

.Synopsis

Converts a hashtable into a string representation of all its values

function Convert-HashtableToString

{

param([System.Collections.Hashtable]$Hashtable, [Switch]$Recurse)

# Add @{ only once to the text

if (!$PSBoundParameters.ContainsKey("Recurse"))

{

$hashtext = "@{"

}

# cannot use foreach because I have to catch the last loop for adding }

for($i=0;$i -lt $Hashtable.Keys.Count;$i++)

{

# get the current key

$k = @($Hashtable.Keys)[$i]

# get the current value

$v = $Hashtable[$k]

# check if value is a hashtable

if ($v -is [System.Collections.Hashtable])

{

$hashtext += "$k=@{"

# call function recursively

$hashtext += Convert-HashToString -Hashtable $v -Recurse

$hashtext += ";"

}

# check if value is an array

elseif ($v -is [System.Array])

{

$hashtext += "$k=@("

$hashtext += $v.ForEach{"'$_'"} -join ","

$hashtext += ");"

}

else

{

$hashtext += $k + "=" + "`"$v`"" + ";"

}

# if last loop add } to the output

if ($i -eq $Hashtable.Keys.Count -1 )

{

$hashtext += "}"

}

# return the text - no need for a return statement

$hashtext

}

So this should work. I have tested the function with a specific psd1 file. If not please leave a comment or send me a mail.

PowerShell Core 6.1 mit interessanten Neuerungen

Schreibe eine Antwort

Am Anfang fand ich die Idee gut, dann war ich etwas skeptisch, inzwischen bin aber überzeugt, dass PowerShell Core die Zukunft der PowerShell ist. Seit einigen Monaten arbeite ich nahezu ausschließlich mit PowerShell Core was mir insofern leicht fällt, da ich kein Administrator bin, der beruflich die PowerSHell einsetzt und damit auf Module angewwiesen ist, die sich unter PowerShell Code nicht nutzen lassen, wenngleich dies nur noch auf wenige Module zutreffen dürfte.

Im Windows-Umfeld bringt PowerShell Core nur wenige Vorteile. Im Gegenteil, bedingt durch den Umstand, dass „Core“ bedeutet, dass PowerShell Code auf .NET Core und nicht .NET Framework basiert und und in .NET Core 2.0 einige APIs fehlten, die von PowerShell-Commands vorausgesetzt werden, waren bestimmte Aufrufe, etwa WMI, einfach nicht möglich. Unter Windows ist das natürlich kein Thema, denn man bleibt ganz einfach bei der Windows PowerShell.

Microsoft wäre nicht Microsoft, wenn es seine Anmwender/Kunden nicht zu irgendetwas „zwingen“ würde. Wir sollen alle in die Cloud gehen, also gibt es bei Windows Server mit jeder Version weniger Innovationen (wenngleich auch Windows Server 2019 interessante Neuerungen enthält). Da in Zukunft nur noch PowerShell Core weiterentwickelt wird, sollen Administratoren in Zukunft eher mit diseser Version arbeiten. Da bei .NET Core in der Vergangenheit wichtige APis fehlten, die es nur unter Windows gibt, wurden diese in Gestalt der „Compatibilty Packs“ inzwischen nachgereicht. Damit ist auch bei PowerShell Core z.B. WMI wieder möglich. Natürlich nur unter Windows.

Trotzdem fallen mir nur wenige Gründe ein, warum ein Administrator unter Windows anstelle der Windows PowerShell PowerShell Core verwenden sollte.

Nachdem im Januar 2018 die Version 6.0 freigegeben wurde, erschien im September 2018, also etwa mehr als ein halbes Jahr später, die Version 6.1.

Sie wird im Blog des PowerShell-Teams ausführlich vorgestellt:

https://blogs.msdn.microsoft.com/powershell/2018/09/13/announcing-powershell-core-6-1/

und vorallem

https://docs.microsoft.com/en-us/powershell/scripting/whats-new/what-s-new-in-powershell-core-61?view=powershell-6

Der Vollständigkeit halber habe ich die wichtigsten Neuerungen noch einmal stichwortartig zusammengefasst:

>Umstellung auf .NET Core 2.1
>Performance-Verbesserungen, z.B. bei Import-CSV
>Über die Eigenschaft PSEdition lässt sich bei Modulen abfragen, ob wie für Core, Desktop oder beide in Frage kommen. Diese Information muss aber in die Manifestdatei eingetragen werden, damit sie abgefragt werden kann
>Es gibt Cmdlets für den Umgang mit Markdown (sehr praktisch)
>Das Invoke-WebRequest-Cmdlet wurde verbessert
>Das Enable-PSSession-Cmdlet wurde verbessert
>Ein cd – führt zum letzten Verzeichnis zurück
>Ein cd– führt in das $Home-Verzeichnnis
>Für Update-Help muss die PowerShell nicht mehr als Administrator gestartet werden
>Ein [PSCustomObject]-Objekt besitzt jetzt eine Length- und Count-Eigenschaft

Bemerkenswert und im Grunde naheliegend ist, dass einige der Verbesserungen aus der Community stammen.

Tipps für Zwischendurch: Fenster auflisten mit der EnumWindows-API-Funktion

Schreibe eine Antwort

Vor kurzem fand ich nach der Suche nach einer Lösung auf Stackoverflow einen Link auf ein PowerShell-Skript, das ich vor vielen Jahren erstellt hatte. Leider hatte der Autor meinen Namen nicht erwähnt, sonst wäre ich bei Stackoverflow zu unverhofftem Ruhm gekommen. Außerdem verwies der Autor des Beitrags auf meinen alten Blog powershell-knowhow.de, den es schon länger nicht mehr gibt. Da ich das Skript von damals auf diversen Festplatten nicht wiederfinden konnte, musste ich mich noch einmal an die Arbeit machen. Wie sooft war das Ergebnis besser als das Original, da es deutlich kürzer geworden ist. Das ist generell ein Erfahrungswert, den ich aus über 10 Jahren PowerShell ziehen kann, und der vermutlich universell gilt. Um auf die kürzeste Lösung zu kommen, muss man sich in den Bereich, in dem die Lösung gesucht wird, bereits ziemlich gut auskennen.

Wie dem auch sei, die folgende Function Get-WindowData gibt Fensterhandle und Text zu jedem Top-Window-Fenster aus (und das sind bereits erstaunlich viele). Theoretisch lassen sich durch eine Art rekursiven Aufruf natürlich auch die Kindfenster eines Fensters auflisten, aber diese Mühe habe ich mir dann doch nicht gemacht.

Interesant und lehrreich an dem Beispiel ist die Leichtigkeit, mit der sich ein „Callback“, also eine Adresse auf eine Funktion, die von der API-Funktion pro Fenster aufgerufen wird, von PowerShell an eine Win32-API-Funktion übergeben lässt. Merkregel: Überall, wo ein Delegate erwartet wird, darf auch ein Scriptblock übergeben werden.

<#
 .Synopsis
 Win32-Fensterliste mit Callback
#>

function Get-WindowData
{
    [CmdletBinding()]
    param()
    $APIDef = @'
    public delegate bool CallBackPtr(int hwnd, int lParam);
    [DllImport("User32.dll", CharSet=CharSet.Auto, SetLastError=true)]
    public static extern bool EnumWindows(CallBackPtr lpEnumFunc, IntPtr lParam);
    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder lpString, int nMaxCount);
'@

    $Win32 = Add-Type -Namespace Win32 -MemberDefinition $ApiDef -Name APIFunctions

    $Script:WindowsList = @()

    $Action = {
       Param (
            [Int]$hwnd,
            [Int]$lParam
        )
        $SB = [System.Text.StringBuilder]::new(256)
        [Win32.ApiFunctions]::GetWindowText([IntPtr]$hWnd, $Sb, 256)
        $WindowText = $Sb.ToString()
        If ($WindowText.Length -gt 1)
        {
            Write-Verbose "Hwnd: $hwnd Text=$WindowText"
            $Script:WindowsList += [PSCustomObject]@{Hwnd=$hwnd;WindowText=$WindowText}
        }
        return $true
    }
    # ist nicht zwingend erforderlich - macht aber einen besseren Eindruck;)
    $ActionDelegate = [Func[int, int, Bool]]
    $EnumChildProc = $Action -as $ActionDelegate
    [void][Win32.APIFunctions]::EnumWindows($Action, [IntPtr]::Zero)
    $WindowsList
}

.Synopsis

Win32-Fensterliste mit Callback

function Get-WindowData

{

[CmdletBinding()]

param()

$APIDef = @'

public delegate bool CallBackPtr(int hwnd, int lParam);

[DllImport("User32.dll", CharSet=CharSet.Auto, SetLastError=true)]

public static extern bool EnumWindows(CallBackPtr lpEnumFunc, IntPtr lParam);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]

public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder lpString, int nMaxCount);

$Win32 = Add-Type -Namespace Win32 -MemberDefinition $ApiDef -Name APIFunctions

$Script:WindowsList = @()

$Action = {

Param (

[Int]$hwnd,

[Int]$lParam

)

$SB = [System.Text.StringBuilder]::new(256)

[Win32.ApiFunctions]::GetWindowText([IntPtr]$hWnd, $Sb, 256)

$WindowText = $Sb.ToString()

If ($WindowText.Length -gt 1)

{

Write-Verbose "Hwnd: $hwnd Text=$WindowText"

$Script:WindowsList += [PSCustomObject]@{Hwnd=$hwnd;WindowText=$WindowText}

}

return $true

}

# ist nicht zwingend erforderlich - macht aber einen besseren Eindruck;)

$ActionDelegate = [Func[int, int, Bool]]

$EnumChildProc = $Action -as $ActionDelegate

[void][Win32.APIFunctions]::EnumWindows($Action, [IntPtr]::Zero)

$WindowsList

}

Kleine Tipps für Zwischendurch: Kopfzeile und restliche Zeilen einer Textdatei mit einem Befehl getrennt einlesen

Schreibe eine Antwort

Bei einer Textdatei sollen Kopfzeile und die restlichen Zeilen getrennt eingelesen werden. Aber mit einem einzigen Befehl.

Mit folgender Konstruktion ist mir das gelungen.

Zunächst ein paar Testdaten als Here-String:

$TxtDaten = @"
Spalte1,Spalte2
100,101,111
200,201,222
"@

$TxtDaten = @"

Spalte1,Spalte2

100,101,111

200,201,222

Dann der Befehl, der die Textzeilen in eine erste Zeile und die restlichen Zeilen aufsplittet und das Ergebnis zwei Variablen zuweist:

$Head, $Lines = $TxtDaten -split "`n" | &{  End {$Values=@($input);$ValCount = $Values.Count;$Values[0]; $Values[1..$ValCount] }}

1	$Head, $Lines = $TxtDaten -split "`n" \| &{ End {$Values=@($input);$ValCount = $Values.Count;$Values[0]; $Values[1..$ValCount] }}

Warum verwende ich kein ForEach-Object? In erster Linie weil ich es etwas „übertrieben“ finde, wenn ein Wiederholungsbefehl für einen einzigen Verarbeitungschritt verwendet werden muss. Auch wollte ich keine Variable verwenden. Dann wäre auch Folgendes möglich:

$Zeilen = $TxtDaten -split "`n"
$Head, $Lines = $Zeilen[0], $Zeilen[1..($Zeilen.Count -1)]

1 2	$Zeilen = $TxtDaten -split "`n" $Head, $Lines = $Zeilen[0], $Zeilen[1..($Zeilen.Count -1)]

Die Variable Zeilen wird gebraucht, da ich nur so an die Länge des Array beim Zugriff auf dasselbige herankomme.

Es soll direkt nach dem Schema Textzeilen | Verarbeitung => Ergebnis funktionieren. Ohne Zwischenschritte und Variablen.

Was nicht jeder wissen dürfte, auch eim harmloser Scriptblock kann in einen Begin-, Process- und End-Block unterteilt werden. Möchte man in einen Scriptblock etwas pipen, geht das nur mit eimem vorangestellten &, das den Scriptblock ausführt.

Tja, was soll man davon halten? Es funktioniert, ok. Ist das Ganze intuitiv nachvollziehbar? Eher weniger. Auf der anderen Seite, im Vergleich zu einem Befehl in Bash oder Perl, der zum selben Resultat führt, ist die PowerShell-Variante regelrecht leicht verdaulich, denn es kommen weder reguläre Ausdrücke noch kryptische Variablen wie %%S vor;)

Tipps für Zwischendurch: COM-Methoden mit Enum-Werten aufrufen

Schreibe eine Antwort

Dieser Tipp ist etwas spezieller.

Ausgangspunkt ist eine COM-Dll (früher OLE Server oder COM Server genannt), die eine Methode Calculate anbietet, die drei Parameter besitzt. Der erste Parameter ist vom Typ eines Enum mit dem Namen „OpType“, die anderen beiden Parameter sind vom Typ int.

Das Anlegen eines COM-Objekts mit der ProgId ist einfach:

$m = New-Object -ComObject MathLibV1.Mathclass

1	$m = New-Object -ComObject MathLibV1.Mathclass

Der Aufruf von Calculate funktioniert zunächst nur, wenn für den Enum-Wert eine Zahl übergeben, z.B. eine 0.

$m.Calculate(0, 4, 5)

1	$m.Calculate(0, 4, 5)

Der Enum OpType ist zunächst nicht bekannt. Ein „Trick“ besteht darin, ihn per Enum-Befehl nachzubauen, den es ab Version 5.0 gibt.

Enum OptType
{
 Add
 Subtract
 Mul
 Div
}

Enum OptType

{

Add

Subtract

Mul

Div

}

Damit klappt auch der folgende Aufruf:

$m.Calculate([OpType]::Add, 4, 5)

1	$m.Calculate([OpType]::Add, 4, 5)

PowerShell-Admin

PowerShell-Know-how von PowerShell-Experte, Entwickler, Autor und Trainer Peter Monadjemi

Archiv des Autors: PemoAdmin

Module in einer Remote-Session global importieren am Beispiel von Office 365/Exchange Online

Kleine Tipps für Zwischendurch: Datumszeitangaben im UTC-Format konvertieren

Einen Access Token für Microsoft Graph erhalten

Kleine Tipps für Zwischendurch: PowerShell Core-Module aus der PowerShell Gallery auflisten

Die Beispiele zu meinem Vortrag auf der Basta! 2018

Convert a hashtable into its string representation

PowerShell Core 6.1 mit interessanten Neuerungen

Tipps für Zwischendurch: Fenster auflisten mit der EnumWindows-API-Funktion

Kleine Tipps für Zwischendurch: Kopfzeile und restliche Zeilen einer Textdatei mit einem Befehl getrennt einlesen

Tipps für Zwischendurch: COM-Methoden mit Enum-Werten aufrufen