Inconsistencies? in ImmutableArrayExtensions.cs

[Saborion]

The summary for the class ImmuableArrayExtensions says "LINQ extension method overrides that offer greater efficiency for ImmutableArray<T> than the standard LINQ methods". Having looked through the class and compared the method implementations to the respective LINQ methods I believe I can understand how it is done. There seem to be inconsistencies between the ImmutableArrayExtension methods, however, and I am curious why; is it because different programmers added different methods and did not follow existing patterns, or is it because the pattern was improved with time, or is it because of some performance reason?

Guard Clauses:
Only 11/29 methods use the immutableArray.ThrowNullRefIfNotInitialized() guard clause.
Even stranger is the fact that there are "related methods" where one method has the guard clause and the other does not, such as public static T Single<T>(this ImmutableArray<T> immutableArray) that has it and public static T Single<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate) that does not.

Custom Implementations vs LINQ Calls:
There are some methods that, as far I can tell, have no custom implementation but simply calls the LINQ extension method. Compare the following two methods:

public static T Last<T>(this ImmutableArray<T> immutableArray)
{
    // In the event of an empty array, generate the same exception
    // that the linq extension method would.
    return immutableArray.Length > 0
        ? immutableArray[immutableArray.Length - 1]
        : Enumerable.Last(immutableArray.array!);
}

public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray)
{
    immutableArray.ThrowNullRefIfNotInitialized();
    return immutableArray.array!.LastOrDefault()!;
}

I would have expected the latter to written as

public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray)
{
    immutableArray.ThrowNullRefIfNotInitialized();
    return immutableArray.Length > 0
        ? immutableArray[immutableArray.Length - 1]
        :  default;
}

Am I wrong in thinking that the public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray) provides no benefit over the matching LINQ method? Perhaps even worse performance due to the additional method call?

I am in the process of copying the ImmutableArray type but changing the implementation to use value semantics. The "inconsistencies" above made me curious if there is some voodoo going on and I should leave the methods as is, or if I should update them in my implementation.

[huoyaoyuan]

"LINQ extension method overrides that offer greater efficiency for ImmutableArray than the standard LINQ methods".

Because calling LINQ through the IEnumerable<T> interface would require boxing of the ImmutableArray<T> instance, which is a struct. Calling through the underlying array would solve this.