// given similar API:
public class MyDataReader : IDataReader
{
    IEnumerable<IField> Fields { get; set;}
    IField GetField(string name) => Fields.SingleOrDefault(f=>f.ColumnName == name);
    // (...)
 }
public class Field : IField
{
    Field (string name, object value)
    {
        ColumnName = name;
        DataValue = value;
    }
    string ColumnName { get; }
    object DataValue { get; }
}

// Arrange
// values are both incorrect (swapped), column-/fieldname "Name" is different from expected "LastName"
var myRecord = new Field[] { new("FirstName", "Doe"), new("Name", "John") };
var dr = new MyDataReader { Fields = myRecord };
string input = "MyString";

// Act
bool result = dr.Read();

// Assert
result.Should().BeTrue();
using (new AssertionScope)
{
    // Expected "LastName", but actual is "Name"
    dr.Fields.Should().ContainSingle(field=>field.ColumnName=="LastName").Which.DataValue.Should().Be("Doe");
    // Because .Which above throws, the below code is not executed, but its results are expected to be included in the output.  
    dr.Fields.Should().ContainSingle(field=>field.ColumnName=="FirstName").Which.DataValue.Should().Be("John"); // <== Mismatches found here are not in the output
}

using (new AssertionScope)
{
    // Expected "LastName", but actual is "Name"
    using (var inner = new AssertionScope()) // isolated inner scope (in case there is an assertion added above that resulted in a failure)
        if (dr.Fields.Should().ContainSingle(field=>field.ColumnName=="LastName") is var constraint && !inner.HasFailures())
            constraint.Which.DataValue.Should().Be("Doe");
     // Because .Which above is now only accessed if there is no failure, it will not throw, so the below code is executed, and results are included in the output.
     // Has no effect here now, but there may be assertions added below in the future
     using (var inner = new AssertionScope()) // isolated inner scope (so we now hasFailure would always be caused by this assertion)
        if (dr.Fields.Should().ContainSingle(field=>field.ColumnName=="FirstName") is var constraint && !inner.HasFailures())
            constraint.Which.DataValue.Should().Be("John"); // <== Mismatches found here are now in the output
}

using (var scope = new AssertionScope)
{
    // using extension (A)
    if (scope.IsSuccessful(() => dr.Fields.Should().ContainSingle(field => field.ColumnName == "LastName")
        // dr.GetField("LastName").DataValue.Should().Be("Doe");
        dr.Fields.Single(field => field.ColumnName == "LastName").DataValue.Should().Be("Doe");
    // (...)
    // or (B)
    scope.IfSuccessful(() => dr.Fields.Should().ContainSingle(field => field.ColumnName == "LastName")
        field => field.DataValue.Should().Be("Doe"));
        // _ => dr.Fields.Single(field => field.ColumnName == "LastName").DataValue.Should().Be("Doe"); // would work too and adds some more context to the output.
    // (...)
}

public static class FluentAssertionExtensions
{
    // extending on AssertionScope to reduce chance to have them apply in code where they are not relevant

    // alternative A
    public static bool IsSuccessful(this IAssertionScope _ , Action evaluateConstraint)
    {
        using var scope = new AssertionScope();
        evaluateConstraint();
        return !scope.HasFailures();
    }
    // alternative B
    public static void IfSuccessful<TParent, T>(this IAssertionScope _ , Func<AndWhichConstraint<TParent,T>> constraintFunc, Action<T> evaluateItem)
    {
        using var scope = new AssertionScope();
        var constraint = constraintFunc();
        if (!scope.HasFailures())
             evaluateItem(constraint.Which);
    }
    // alternative C (quick and dirty - use of exception for control flow)
    public static void IfSuccessful<TParent, T>(this AndWhichConstraint<TParent, T> constraint, Action<T> code)
    {
        T subject;
        try { subject = constraint.Which!; }
        catch (Exception) { return; }
        code(subject);
    }
}