Summary

This PR implements the API proposal from #2390 to add a cleaner, more intuitive way to exclude all members of a certain type from structural equivalency assertions, with full support for inheritance and generic type hierarchies.

Motivation

Previously, to exclude all members of a specific type (e.g., TimeSpan), you had to write verbose predicate expressions:

options.Excluding(mi => mi.Type == typeof(TimeSpan))

For interfaces, the syntax was even more complex:

options.Excluding(mi => typeof(IEnumerable<int>).IsAssignableFrom(mi.Type))

And for open generic types like Nullable<>, it was quite cumbersome:

options.Excluding(mi => mi.Type.IsGenericType && 
                         mi.Type.GetGenericTypeDefinition() == typeof(Nullable<>))

Changes

This PR adds two new methods to SelfReferenceEquivalencyOptions<TSelf>:

1. Generic Method: Excluding<TMember>()

subject.Should().BeEquivalentTo(expectation, options => options
    .Excluding<TimeSpan>());

2. Type Parameter Method: Excluding(Type type)

subject.Should().BeEquivalentTo(expectation, options => options
    .Excluding(typeof(Nullable<>)));

Features

Type Matching with Inheritance Support

For non-sealed types, the exclusion includes all derived types:

options.Excluding<BaseClass>()  // Excludes BaseClass and all types deriving from it

Sealed Type Matching

For sealed types (like string), only exact matches are excluded:

options.Excluding<string>()  // Excludes only string (sealed type)

Interface and Abstract Type Support

For interfaces and abstract types, all implementing/derived types are excluded:

options.Excluding<IEnumerable<int>>()  // Excludes List<int>, int[], HashSet<int>, etc.

Open Generic Type Matching with Full Inheritance Support

Supports excluding all closed generics and types deriving from them:

options.Excluding(typeof(Nullable<>))        // Excludes int?, double?, DateTime?, etc.
options.Excluding(typeof(OpenGeneric<>))    // Excludes OpenGeneric<int>, DerivedOpenGeneric<T>, etc.

This includes:

• Closed generics: class ClosedGeneric : OpenGeneric<int>
• Derived open generics: class DerivedOpenGeneric<T> : OpenGeneric<T>
• Closed derived generics: class ClosedDerivedGeneric : DerivedOpenGeneric<int>

Multiple Exclusions

Methods can be chained for excluding multiple types:

options.Excluding<TimeSpan>()
       .Excluding<DateTime>()
       .Excluding<double>()

Works at All Nesting Levels

Exclusions apply throughout the entire object graph, including nested objects and collections.

Implementation Details

• Added new ExcludeMemberByTypeSelectionRule class that implements IMemberSelectionRule
• The rule intelligently handles multiple scenarios:
  • Sealed types: Uses exact type equality (memberType == targetType)
  • Non-sealed types: Uses assignability check to include derived types (targetType.IsAssignableFrom(memberType))
  • Open generic types: Matches closed generics and checks inheritance hierarchy for all derived types
• Comprehensive XML documentation for all public APIs
• Updated documentation in objectgraphs.md and releases.md

Testing

• Added 21 unit tests covering all scenarios including inheritance cases
• All 628 existing equivalency tests pass (no regressions)
• Full test suite: 5,875+ tests passing
• Manual verification confirms all use cases work correctly

Breaking Changes

None. This is a purely additive change that maintains full backward compatibility.

Fixes #2390

---

This section details on the original issue you should resolve

<issue_title>[API Proposal]: Allow BeEquivalentTo to exclude all members of a certain type</issue_title>
<issue_description>### Background and motivation

A shortcut to options.Excluding(mi => mi.Type == typeof(TimeSpan));

API Proposal

public abstract class SelfReferenceEquivalencyAssertionOptions<TSelf> : IEquivalencyOptions
    where TSelf : SelfReferenceEquivalencyAssertionOptions<TSelf>
{
    public TSelf Excluding<TMember>()
    {
    }
}

Also supports excluding all members whose type is assignable to IMyInterface

options.Excluding<IMyInterface>();

And excludeing all members whose type is a closed generic of Nullable<T>, i.e. it excludes int?, double?, etc.

options.Excluding(typeof(Nullable<>))

API Usage

Instead of options.Excluding(mi => mi.Type == typeof(TimeSpan));, you can do options.Excluding<TimeSpan>()

Alternative Designs

Maybe name it ExcludingMembersOfType<T>

Risks

No response

Are you willing to help with a proof-of-concept (as PR in that or a separate repo) first and as pull-request later on?

No</issue_description>

Comments on the Issue (you are @copilot in this section)

@jnyrup Should this also be able to handle polymorphism and open generic types?

Examples:

Excludes all members whose type is assignable to MyInterface

options.Excluding<MyInterface>()

Excludes all members whose type is a closed generic of Nullable<T>, i.e. it excludes int?, double?, etc.

options.Excluding(typeof(Nullable<>))
```</body></comment_new>
<comment_new><author>@dennisdoomen</author><body>
I like that. Let's do that.</body></comment_new>
</comments>

Fixes #3114

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.