Comparing structs for equality without boxing

Question

I came across an extension method that applies to structs (SomeStruct) and returns whether or not the value is equal to the default(SomeStruct) (when the parameterless constructor is called).

public static bool IsDefault<T> (this T value)
    where T : struct
{
    return (!EqualityComparer<T>.Default.Equals(value, default(T)));
}

This got me wondering whether the struct was being boxed. This is purely out of curiosity as there are pros/cons to boxing/passing by value depending on the context.

Assumptions:

1. The first of the following methods is illegal since structs do not implicitly override the equality operators ==/!=.
2. The second "appears" to avoid boxing.
3. The third method should always box the struct since it's calling object.Equals(object o).
4. The fourth has both overloads available (object/T) so I'm assuming it will avoid boxing as well. However, the target struct would need to implement the IEquatable<T> interface, making the helper extension method not very helpful.

Variations:

public static bool IsDefault<T> (this T value)
    where T : struct
{
    // Illegal since there is no way to know whether T implements the ==/!= operators.
    return (value == default(T));
}

public static bool IsDefault<T> (this T value)
    where T : struct
{
    return (!EqualityComparer<T>.Default.Equals(value, default(T)));
}

public static bool IsDefault<T> (this T value)
    where T : struct
{
    return (value.Equals(default(T)));
}

public static bool IsDefault<T> (this T value)
    where T : struct, IEquatable<T>
{
    return (value.Equals(default(T)));
}

This question is about confirming the above assumptions and if I am misunderstanding and/or leaving something out.

Answer 1

1. The first of the following methods is illegal since structs do not implicitly override the equality operators ==/!=.

True.

2. The second "appears" to avoid boxing.

The signature of the called method is EqualityComparer<T>.Equals(T,T) which uses the type T for the parameters, so it does not require boxing to call.

The implementation of the default comparer checks if T is IEquatable<T> and if so uses a comparer that uses IEquatable<T>.Equals and else uses a comparer for Object.Equals, so internally there might be boxing applied if the struct is not IEquatable ('only if needed').

3. The third method should always box the struct since it's calling object.Equals(object o).

True.

4. The fourth has both overloads available (object/T) so I'm assuming it will avoid boxing as well. However, the target struct would need to implement the IEquatable interface, making the helper extension method not very helpful.

Yes, it does not require boxing, as per this SO answer. This is the effective code you get for the specific case of T : IEquatable from the EqualityComparer<T>.Default.