Proposal: null-propagating with syntax

[RenderMichael]

Pretty straightforward proposal, a natural extension of the existing functionality, and (I assume) fairly low-cost.

I imagine the most natural syntax looks like

potentionallyNullRecord with? { NewValue = x }

or possibly

potentionallyNullRecord? with { NewValue = x }

[Rekkonnect]

The syntax choice will be affected if await?, foreach?, return?, yield return?, throw? and alike get introduced. The with? choice provides a null alternative to a keyword that operates on a non-null operand, throwing otherwise. Since I'm personally in favor of getting those alternatives, I'll support the with? variant.

[RenderMichael]

Do you have use cases where storing the maybe-null exception in an Exception variable rather than an ExceptionDispatchInfo variable is the right thing to do?

My use case for this is an automation framework I've build around NUnit (I'd love to link it but it's an internal company product).
Generally it goes like

private Exception? Exception;
private bool Passed => exception is not null;
private ILogger _logger;

public void AssertCondition()
{
    try
    {
        Assert.That(...);
    }
    catch (AssertionException ex)
    {
        Exception = ex;
    }
    finally
    {
        _logger.LogInformation($"Additional logging out of NUnit's scope. {(Passed ? '✓' : '❌')}")
        Exception?.Rethrow();
    }
}

[jnm2]

Have you considered exception filters to avoid stack unwinding and rethrowing?

private Exception? exception;
private bool Passed => exception is not null;
private ILogger _logger;

private bool RecordExceptionWithoutCatching(Exception ex)
{
    exception = ex;
    return false;
}

public void AssertCondition()
{
    try
    {
        Assert.That(...);
    }
    catch (AssertionException ex) when (RecordExceptionWithoutCatching(ex))
    {
    }
    finally
    {
        _logger.LogInformation($"Additional logging out of NUnit's scope. {(Passed ? '✓' : '❌')}");
    }
}

[jnm2]

Also, be careful about expecting an exception when an NUnit assertion fails. NUnit doesn't throw exceptions for assertion failures inside Assert.Multiple blocks. A more robust way to check for failure is via TestContext.CurrentContext.Result.Outcome:

private bool Passed => TestContext.CurrentContext.Result.Outcome.Status != TestStatus.Failed;
private ILogger _logger;

public void AssertCondition()
{
    try
    {
        Assert.That(...);
    }
    finally
    {
        _logger.LogInformation($"Additional logging out of NUnit's scope. {(Passed ? '✓' : '❌')}");
    }
}

[RenderMichael]

I considered that, but then the following code

Assert.Multiple(() =>
{
    AssertSomethingFalse();
    AssertSomethingTrue();
}

Would end up producing logs like

Additional logging: ❌
Additional logging: ❌

when the correct solution would be

Additional logging: ❌
Additional logging: ✓

If NUnit's CurrentContext had a property like ResultOfLastAssertionInMultipleBlock then it would be feasible, but at the moment I just tell internal consumers of the library not to use Assert.Multiple

[jnm2]

Gotcha. I'd still recommend using a catch filter rather than rethrowing, and then I'm back to not knowing of motivating cases where the maybe-null variable should be Exception and not ExceptionDispatchInfo.

[jnm2]

I could really use with?. This pattern is coming up a lot:

return state with
{
    SomeDialog = state.SomeDialog is null ? null : state.SomeDialog with
    {
        SomeTextBox = state.SomeDialog.SomeTextBox with { Value = newValue },
    },
};

I'd like to be able to write this instead:

return state with
{
    SomeDialog = state.SomeDialog with?
    {
        SomeTextBox = state.SomeDialog.SomeTextBox with { Value = newValue },
    },
};

I also want to be able to collapse this structure like #4587 specifies, but with ?. also being available:

return state with { SomeDialog?.SomeTextBox.Value = newValue };

[RenderMichael]

The latter part goes hand-in-hand with #6045

[jnm2]

with on nullable objects had a mention from an LDM member at #6045 (comment).