PR Summary

Adds a new -SkipUnsupportedTypes switch parameter to ConvertTo-Json that allows dictionaries with non-string keys (like Exception.Data) to be converted to JSON by silently skipping the problematic entries instead of throwing an error.

Fixes #5749

PR Context

Problem

When converting objects containing dictionaries with non-string keys (such as Exception.Data which uses IDictionary with object keys), ConvertTo-Json throws NonStringKeyInDictionary error, making it impossible to serialize such objects.

Solution

Added a new -SkipUnsupportedTypes switch parameter that, when specified, silently skips dictionary entries with non-string keys instead of throwing an error. This allows users to convert objects like exceptions to JSON while gracefully handling unsupported dictionary entries.

PR Checklist

• PR has a meaningful title
  • Use the present tense and imperative mood when describing your changes
• Summarized changes
• Make sure all .h, .cpp, .cs, .ps1 and .psm1 files have the correct copyright header
• This PR is ready to merge. If this PR is a work in progress, please open this as a Draft Pull Request and mark it as Ready to Review when it is ready to merge.
• Breaking changes
  • None
• User-facing changes
  • Not Applicable
  • OR
  • Documentation needed
    • Issue filed:
• Testing - New and feature
  • N/A or can only be tested interactively
  • OR
  • Make sure you've added a new test if existing tests do not effectively test the code changed

Changes Made

1. ConvertToJsonCommand.cs (+9 lines)

• Added SkipUnsupportedTypes switch parameter

2. JsonObject.cs (+36 lines, -1 line)

• Added SkipUnsupportedTypes field to ConvertToJsonContext struct
• Added new 7-parameter constructor overload with skipUnsupportedTypes parameter
• Modified existing 3-parameter and 6-parameter constructors to chain to 7-parameter version
• Added skip logic in ProcessDictionary method to skip non-string key entries when enabled

3. ConvertTo-Json.Tests.ps1 (+177 lines)

• Added 17 comprehensive tests covering new functionality and backward compatibility

Total: 3 files changed, 221 insertions(+), 1 deletion(-)

Behavior Examples

Before (throws error)

$ex = [System.Exception]::new("Test")
$ex.Data.Add(1, "one")
$ex | ConvertTo-Json
# Error: NonStringKeyInDictionary

After (with -SkipUnsupportedTypes)

$ex = [System.Exception]::new("Test")
$ex.Data.Add(1, "one")
$ex | ConvertTo-Json -SkipUnsupportedTypes
# Successfully converts, skipping the non-string key entry in Data

Without -SkipUnsupportedTypes (unchanged behavior)

$ex | ConvertTo-Json
# Still throws NonStringKeyInDictionary error (backward compatible)

Testing

Test Categories (17 tests total)

Backward Compatibility Tests (7 tests) - Pass on both production and build versions:

• String key dictionaries work without changes
• Default error behavior unchanged
• Complex objects work without changes
• 3-parameter constructor callable
• 6-parameter constructor callable

New Feature Tests (10 tests) - Pass on build version only:

• Skip dictionary with non-string keys with SkipUnsupportedTypes
• Convert Exception with SkipUnsupportedTypes
• Mixed dictionary handling
• Nested objects with unsupported types
• 7-parameter constructor with SkipUnsupportedTypes
• SkipUnsupportedTypes defaults to false in existing constructors

Test Results

Implementation Details

Scope

This change only affects dictionary entries with non-string keys. All other JSON conversion behavior remains unchanged.

Design Decisions

1. Switch parameter - Simple on/off behavior, defaults to off (backward compatible)
2. Silent skip - No warning when skipping entries (consistent with similar PowerShell behaviors)
3. Entry-level granularity - Only skips problematic entries, not entire dictionaries
4. Constructor chaining - Existing constructors chain to new 7-parameter version for maintainability

Backward Compatibility

• API Level: Existing 3-parameter and 6-parameter constructors preserved and work identically
• Behavior Level: Default behavior (without -SkipUnsupportedTypes) unchanged
• Test Verification: Backward compatibility tests pass on production PowerShell