Performance in .NET Core

Вот откуда берутся эти «догадки», весь .NET открыт для изучения:



String.Equals

public bool Equals(string value, StringComparison comparisonType)
{
	if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
	{
		throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType");
	}
	if ((object)this == value)
	{
		return true;
	}
	if (value != null)
	{
		switch (comparisonType)
		{
		case StringComparison.CurrentCulture:
			return CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.None) == 0;
		case StringComparison.CurrentCultureIgnoreCase:
			return CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.IgnoreCase) == 0;
		case StringComparison.InvariantCulture:
			return CultureInfo.InvariantCulture.CompareInfo.Compare(this, value, CompareOptions.None) == 0;
		case StringComparison.InvariantCultureIgnoreCase:
			return CultureInfo.InvariantCulture.CompareInfo.Compare(this, value, CompareOptions.IgnoreCase) == 0;
		case StringComparison.Ordinal:
			if (Length != value.Length)
			{
				return false;
			}
			return EqualsHelper(this, value);
		case StringComparison.OrdinalIgnoreCase:
			if (Length != value.Length)
			{
				return false;
			}
			if (IsAscii() && value.IsAscii())
			{
				return EqualsIgnoreCaseAsciiHelper(this, value);
			}
			return TextInfo.CompareOrdinalIgnoreCase(this, value) == 0;
		default:
			throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType");
		}
	}
	return false;
}

для ordinal ASCII строк:

private unsafe static bool EqualsIgnoreCaseAsciiHelper(string strA, string strB)
{
	int num = strA.Length;
	fixed (char* ptr = &strA.m_firstChar)
	{
		fixed (char* ptr3 = &strB.m_firstChar)
		{
			char* ptr2 = ptr;
			char* ptr4 = ptr3;
			while (true)
			{
				if (num == 0)
				{
					return true;
				}
				int num2 = *ptr2;
				int num3 = *ptr4;
				if (num2 != num3 && ((num2 | 0x20) != (num3 | 0x20) || (uint)((num2 | 0x20) - 97) > 25u))
				{
					break;
				}
				ptr2++;
				ptr4++;
				num--;
			}
			return false;
		}
	}
}

Для остальных строк:

INT32 QCALLTYPE COMNlsInfo::InternalCompareStringOrdinalIgnoreCase(
    LPCWSTR string1, INT32 index1,
    LPCWSTR string2, INT32 index2,
    INT32 length1,
    INT32 length2)
{
    CONTRACTL
    {
        QCALL_CHECK;
        PRECONDITION(CheckPointer(string1));
        PRECONDITION(CheckPointer(string2));
    } CONTRACTL_END;

    INT32 result = 0;

    BEGIN_QCALL;
    //
    //  Get the arguments.
    //  We assume the caller checked them before calling us
    //

    // We don't allow the -1 that native code allows
    _ASSERT(length1 >= 0);
    _ASSERT(length2 >= 0);

    // Do the comparison
#ifndef FEATURE_CORECLR
    AppDomain* curDomain = GetAppDomain();
    
    if (curDomain->m_pCustomSortLibrary != NULL) {
        result = (curDomain->m_pCustomSortLibrary->pCompareStringOrdinal)(string1 + index1, length1, string2 + index2, length2, TRUE);
    } 
    else 
#endif
    {
        result = NewApis::CompareStringOrdinal(string1 + index1, length1, string2 + index2, length2, TRUE);
    }

    // The native call shouldn't fail
    _ASSERT(result != 0);
    if (result == 0)
    {
        // return value of 0 indicates failure and error value is supposed to be set.
        // shouldn't ever really happen
        _ASSERTE(!"catastrophic failure calling NewApis::CompareStringOrdinal!  This is usually due to bad arguments.");
    }

    // Adjust the result to the expected -1, 0, 1 result
    result -= 2;

    END_QCALL;

    return result;
}

который вызывает WinAPI CompareStringOrdinal

Для Invariant culture строк:

INT32 QCALLTYPE COMNlsInfo::InternalCompareString(
    INT_PTR handle,
    INT_PTR handleOrigin,
    LPCWSTR localeName,
    LPCWSTR string1, INT32 offset1, INT32 length1,
    LPCWSTR string2, INT32 offset2, INT32 length2,
    INT32 flags)
{
    CONTRACTL
    {
        QCALL_CHECK;
        PRECONDITION(CheckPointer(string1));
        PRECONDITION(CheckPointer(string2));
        PRECONDITION(CheckPointer(localeName));
    } CONTRACTL_END;

    INT32 result = 1;
    BEGIN_QCALL;

    handle = EnsureValidSortHandle(handle, handleOrigin, localeName);

#ifndef FEATURE_CORECLR
    AppDomain* curDomain = GetAppDomain();

    if(!(curDomain->m_bUseOsSorting))
    {
        result = SortVersioning::SortDllCompareString((SortVersioning::PSORTHANDLE) handle, flags, &string1[offset1], length1, &string2[offset2], length2, NULL, 0);
    }
    else if (curDomain->m_pCustomSortLibrary != NULL) {
        result = (curDomain->m_pCustomSortLibrary->pCompareStringEx)(handle != NULL ? NULL : localeName, flags, &string1[offset1], length1, &string2[offset2], length2, NULL, NULL, (LPARAM) handle);
    } 
    else 
#endif
    {
        result = NewApis::CompareStringEx(handle != NULL ? NULL : localeName, flags, &string1[offset1], length1, &string2[offset2], length2,NULL,NULL, (LPARAM) handle);
    }

    switch (result)
    {
        case CSTR_LESS_THAN:
            result = -1;
            break;

        case CSTR_EQUAL:
            result = 0;
            break;

        case CSTR_GREATER_THAN:
            result = 1;
            break;

        case 0:
        default:
            _ASSERTE(!"catastrophic failure calling NewApis::CompareStringEx!  This could be a CultureInfo, RegionInfo, or Calendar bug (bad localeName string) or maybe a GCHole.");
            break;
    }

    END_QCALL;
    return result;
}

Который заканчивается в WinAPI CompareStringEx

В кейсе автора

string.Equals(xxx, StringComparison.InvariantCultureIgnoreCase)

Но автор не указал, что хотел именно культурно-инвариантное сравнение (а только то, что хотел более быстрый вариант),
тогда StringComparison.OrdinalIgnoreCase подойдет лучше.

В остальных кейсах надо смотреть. Но для сравнения строк, ToUpper/ToLower всегда будут неправильным решением.

«в огромной бюджетной системе одной страны где выгрузка в Excel и сбор многих данных»

Кривая хрень, короче. Hadoop, Spark, не, не слышали ёксЕль!