Background

The DEFAULT_STACK_SIZE host configuration option (used via the DOTNETCORE_STACK_SIZE macro) is being deleted in dotnet/runtime#118057. We need to migrate to the replacement System.Threading.DefaultStackSize host configuration option, which is documented in dotnet/docs#47575.

What needs to change

There are three files involved across the IIS in-process request handler:

1. src/Servers/IIS/AspNetCoreModuleV2/CommonLib/HostFxr.h

Current:

#define DOTNETCORE_STACK_SIZE L"DEFAULT_STACK_SIZE"

Change to:

#define DOTNETCORE_STACK_SIZE L"System.Threading.DefaultStackSize"

2. src/Servers/IIS/AspNetCoreModuleV2/InProcessRequestHandler/InProcessOptions.cpp

The stack size value is currently stored as a hex string (with optional 0x prefix) — matching what DEFAULT_STACK_SIZE expected. The new System.Threading.DefaultStackSize property requires a decimal number string.

Current (line 68):

m_strStackSize = find_element(handlerSettings, CS_ASPNETCORE_HANDLER_STACK_SIZE).value_or(L"0x100000"); // 1 MB in hex

The default 0x100000 hex = 1048576 decimal (1 MB).

Change to: Parse the configured value (which may be hex with or without 0x prefix, as before) and convert it to a decimal string. The default should become L"1048576" (decimal equivalent of 0x100000).

The logic should be:

1. Read the raw string value from handler settings (same key CS_ASPNETCORE_HANDLER_STACK_SIZE).
2. If the raw value starts with 0x or 0X, parse it as hexadecimal (using wcstoul with base 16) and convert to a decimal wide string.
3. If it doesn't have a 0x prefix but is a valid hex string (the old format allowed hex without the prefix), try parsing it as hexadecimal first (base 16), then convert to decimal.
   • Actually, to keep it simple and match the old behavior: attempt to parse the value as hex (base 16) regardless, since DEFAULT_STACK_SIZE accepted hex with or without 0x prefix. Then format the result as decimal.
4. Store the decimal string in m_strStackSize.
5. The default (when no value is configured) should be L"1048576" (1 MB in decimal).

Here's a concrete implementation approach:

// Parse stack size: config accepts hex (with or without 0x prefix), new API requires decimal
auto rawStackSize = find_element(handlerSettings, CS_ASPNETCORE_HANDLER_STACK_SIZE);
if (rawStackSize.has_value())
{
    const wchar_t* rawStr = rawStackSize.value().c_str();
    wchar_t* endPtr = nullptr;
    // wcstoul handles "0x..." prefix automatically with base 0 or base 16
    // Use base 0 to auto-detect 0x prefix; fall back to base 16 for bare hex
    unsigned long stackSizeVal = wcstoul(rawStr, &endPtr, 16);
    wchar_t decimalBuf[32];
    swprintf_s(decimalBuf, L"%lu", stackSizeVal);
    m_strStackSize = decimalBuf;
}
else
{
    m_strStackSize = L"1048576"; // 1 MB in decimal
}

Note: The old DEFAULT_STACK_SIZE accepted hex with or without 0x prefix. Using base 16 in wcstoul handles both bare hex (e.g. "100000") and prefixed hex (e.g., "0x100000"). The new System.Threading.DefaultStackSize requires decimal, so we convert.

3. src/Servers/IIS/AspNetCoreModuleV2/InProcessRequestHandler/InProcessOptions.h

The QueryStackSize() return type and storage can remain std::wstring — no changes needed here. However, if there are any comments referencing hex or the old format, update them for clarity.

Summary of the change

The inprocessapplication.cpp call site (context->m_hostFxr.SetRuntimePropertyValue(DOTNETCORE_STACK_SIZE, m_pConfig->QueryStackSize().c_str())) does not need to change — it will automatically pick up the new property name via the updated macro and receive the correctly formatted decimal value from QueryStackSize().

The following is the prior conversation context from the user's chat exploration (may be truncated):

User: we currently set the DEFAULT_STACK_SIZE host configuration option to set the stack size. the DEFAULT_STACK_SIZE host configuration option is going to be deleted in @dotnet/runtime/pull/118057

We need to switch to the documented System.Threading.DefaultStackSize host configuration option (docs at @dotnet/docs/pull/47575). These settings are largely equivalent, we just need to swap the DEFAULT_STACK_SIZE string for System.Threading.DefaultStackSize string. Note however that System.Threading.DefaultStackSize accepts the setting as a decimal number. DEFAULT_STACK_SIZE accepted a hexadecimal number with or wi...