How to suppress overflow-checking in PowerShell?

integer-overflow, powershell, unchecked, unchecked-conversion

Solution

The behavior you want in PowerShell is achievable, though, it's a bit of a hack; and maybe there's a better way.

If you just want cryptographic functionality though, it's worth calling out, that there's a TON of that already built-in to the BCL, and it's fully accessible from PowerShell (MD5, SHA, RSA, X509, a ton of other stuff too).

But if you're dead set on performing unchecked arithmetic in PowerShell, this is a hack that should give you what you want (basically we're embedding C# code, and using the unchecked keyword):

$members = @' 
public static UInt32 ToUInt32(int value)
{
    unchecked
    {
        return (UInt32)value;
    }
}


public static byte ToByte(int value)
{
    unchecked
    {
        return (byte)value;
    }
}
'@;

$type = Add-Type -Name "Convert" -Namespace "Helpers" `
        -MemberDefinition $members -PassThru -ErrorAction SilentlyContinue;

Usage:

PS C:\Some\Folder> [Helpers.Convert]::ToUInt32(-1);
4294967295

PS C:\Some\Folder> [Helpers.Convert]::ToByte(-1);
255

PS C:\Some\Folder> [Helpers.Convert]::ToByte(256);
0

Of Note:

- We're calling `[Helpers.Convert]::To...` and not `[System.Convert]::To...`.

- If you need other methods, the actual C# methods will need to be inserted into the `$members` block at the top of the code.

- If you run `Add-Type` multiple times in a row for the same `Namespace` and `Name` combination, in the same PowerShell session, it will fail; and you will be left with the previously registered type. -- I've added `-ErrorAction SilentlyContinue` to ignore this specific scenario. -- That way, you can dump this code into a .ps1 script, and call it every single time, before you use them methods, and they will always be present. -- But if you are modifying the C# code and retesting, you will want to change the type name after every change you make; it's kind of painful.

Problem

PowerShell seems to perform bounds-checking after arithmetic operations and conversions. For instance, the following operations fail: ``` [byte]$a = 255 $a++ $a = [byte]256 ``` Is there any way to enforce overflows or the typecast without resorting to a manual calculation via modulo or C# and Add-Type?

Original source