// Provides a more flexible function for string comparision. See StringComparison
// for meaning of different comparisonType.
public static int Compare(String strA, String strB, StringComparison comparisonType)
{
// Single comparison to check if comparisonType is within [CurrentCulture .. OrdinalIgnoreCase]
if ((uint)(comparisonType - StringComparison.CurrentCulture) > (uint)(StringComparison.OrdinalIgnoreCase - StringComparison.CurrentCulture))
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
if (object.ReferenceEquals(strA, strB))
{
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
return(-1);
}
if (strB == null)
{
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA._firstChar != strB._firstChar)
{
return(strA._firstChar - strB._firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
// If both strings are ASCII strings, we can take the fast path.
if (strA.IsAscii() && strB.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(strA, strB));
}
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
default:
throw new NotSupportedException(SR.NotSupported_StringComparison);
}
}
public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType)
{
CheckStringComparison(comparisonType);
if (strA == null || strB == null)
{
if (object.ReferenceEquals(strA, strB))
{
// They're both null
return(0);
}
return(strA == null ? -1 : 1);
}
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), SR.ArgumentOutOfRange_NegativeLength);
}
if (indexA < 0 || indexB < 0)
{
string paramName = indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
}
if (strA.Length - indexA < 0 || strB.Length - indexB < 0)
{
string paramName = strA.Length - indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
}
if (length == 0 || (object.ReferenceEquals(strA, strB) && indexA == indexB))
{
return(0);
}
int lengthA = Math.Min(length, strA.Length - indexA);
int lengthB = Math.Min(length, strB.Length - indexB);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(strA, indexA, lengthA, strB, indexB, lengthB, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.Ordinal:
return(CompareOrdinalHelper(strA, indexA, lengthA, strB, indexB, lengthB));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(strA, indexA, lengthA, strB, indexB, lengthB));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static int CompareTo(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (span.Length == 0 || value.Length == 0)
{
return(span.Length - value.Length);
}
return(string.CompareOrdinal(span, value));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(span, value));
}
Debug.Fail("StringComparison outside range");
return(0);
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
if ((Object)a == (Object)b)
{
return(true);
}
if ((Object)a == null || (Object)b == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
// If both strings are ASCII strings, we can take the fast path.
if (a.IsAscii() && b.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(a, b));
}
// Take the slow path.
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
}
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
/// <summary>
/// Determines whether the beginning of the <paramref name="span"/> matches the specified <paramref name="value"/> when compared using the specified <paramref name="comparisonType"/> option.
/// </summary>
/// <param name="span">The source span.</param>
/// <param name="value">The sequence to compare to the beginning of the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="value"/> are compared.</param>
public static bool StartsWith(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
string.CheckStringComparison(comparisonType);
if (value.Length == 0)
{
return(true);
}
if (comparisonType >= StringComparison.Ordinal || GlobalizationMode.Invariant)
{
if (string.GetCaseCompareOfComparisonCulture(comparisonType) == CompareOptions.None)
{
return(span.StartsWith(value));
}
return((span.Length >= value.Length) ? (CompareInfo.CompareOrdinalIgnoreCase(span.Slice(0, value.Length), value) == 0) : false);
}
if (span.Length == 0)
{
return(false);
}
return((comparisonType >= StringComparison.InvariantCulture) ?
CompareInfo.Invariant.IsPrefix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType)) :
CultureInfo.CurrentCulture.CompareInfo.IsPrefix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType)));
}
/// <summary>
/// Compares the specified <paramref name="span"/> and <paramref name="other"/> using the specified <paramref name="comparisonType"/>,
/// and returns an integer that indicates their relative position in the sort order.
/// <param name="span">The source span.</param>
/// <param name="other">The value to compare with the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="other"/> are compared.</param>
/// </summary>
public static int CompareTo(this ReadOnlySpan <char> span, ReadOnlySpan <char> other, StringComparison comparisonType)
{
string.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.Ordinal:
if (span.Length == 0 || other.Length == 0)
{
return(span.Length - other.Length);
}
return(string.CompareOrdinal(span, other));
default:
Debug.Assert(comparisonType == StringComparison.OrdinalIgnoreCase);
return(CompareInfo.CompareOrdinalIgnoreCase(span, other));
}
}
/// <summary>
/// Compares the specified <paramref name="span"/> and <paramref name="other"/> using the specified <paramref name="comparisonType"/>,
/// and returns an integer that indicates their relative position in the sort order.
/// <param name="span">The source span.</param>
/// <param name="other">The value to compare with the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="other"/> are compared.</param>
/// </summary>
public static int CompareTo(this ReadOnlySpan <char> span, ReadOnlySpan <char> other, StringComparison comparisonType)
{
string.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.CompareOptionNone(span, other));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.CompareOptionIgnoreCase(span, other));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.CompareOptionNone(span, other));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.CompareOptionIgnoreCase(span, other));
case StringComparison.Ordinal:
if (span.Length == 0 || other.Length == 0)
{
return(span.Length - other.Length);
}
return(string.CompareOrdinal(span, other));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(span, other));
}
Debug.Fail("StringComparison outside range");
return(0);
}
public Boolean StartsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if (value.Length == 0)
{
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (this.Length < value.Length || m_firstChar != value.m_firstChar)
{
return(false);
}
return((value.Length == 1) ?
true : // First char is the same and thats all there is to compare
StartsWithOrdinalHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length < value.Length)
{
return(false);
}
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, value.Length, value, 0, value.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public bool Equals(String value, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if ((Object)value == null)
{
return(false);
}
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 (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
// If both strings are ASCII strings, we can take the fast path.
if (this.IsAscii() && value.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(this, value));
}
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public bool StartsWith(string value, StringComparison comparisonType)
{
if ((object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if ((object)this == (object)value)
{
CheckStringComparison(comparisonType);
return(true);
}
if (value.Length == 0)
{
CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.IsPrefix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (this.Length < value.Length || _firstChar != value._firstChar)
{
return(false);
}
return((value.Length == 1) ?
true : // First char is the same and thats all there is to compare
SpanHelpers.SequenceEqual(
ref Unsafe.As <char, byte>(ref this.GetRawStringData()),
ref Unsafe.As <char, byte>(ref value.GetRawStringData()),
((nuint)value.Length) * 2));
case StringComparison.OrdinalIgnoreCase:
if (this.Length < value.Length)
{
return(false);
}
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, value.Length, value, 0, value.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool StartsWithOrdinalIgnoreCaseHelper(ReadOnlySpan <char> span, ReadOnlySpan <char> value)
{
Debug.Assert(value.Length != 0);
if (span.Length < value.Length)
{
return(false);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span.Slice(0, value.Length), value) == 0);
}
// Provides a more flexible function for string comparision. See StringComparison
// for meaning of different comparisonType.
public static int Compare(String strA, String strB, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
if (object.ReferenceEquals(strA, strB))
{
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
return(-1);
}
if (strB == null)
{
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, 0, strA.Length, strB, 0, strB.Length, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, 0, strA.Length, strB, 0, strB.Length, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA._firstChar != strB._firstChar)
{
return(strA._firstChar - strB._firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(strA, strB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(strA, strB, CompareOptions.IgnoreCase));
default:
throw new NotSupportedException(SR.NotSupported_StringComparison);
}
}
// Provides a more flexible function for string comparison. See StringComparison
// for meaning of different comparisonType.
public static int Compare(string strA, string strB, StringComparison comparisonType)
{
if (object.ReferenceEquals(strA, strB))
{
CheckStringComparison(comparisonType);
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
CheckStringComparison(comparisonType);
return(-1);
}
if (strB == null)
{
CheckStringComparison(comparisonType);
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(strA, strB, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA._firstChar != strB._firstChar)
{
return(strA._firstChar - strB._firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
#if CORECLR
// If both strings are ASCII strings, we can take the fast path.
if (strA.IsAscii() && strB.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(strA, strB));
}
#endif
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
internal static bool EqualsOrdinalIgnoreCase(this ReadOnlySpan <char> span, ReadOnlySpan <char> value)
{
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span, value) == 0);
}
public bool Equals(String value, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
if ((Object)this == (Object)value)
{
return(true);
}
if ((Object)value == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, 0, this.Length, value, 0, value.Length, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, 0, this.Length, value, 0, value.Length, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
else
{
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
}
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(this, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(this, value, CompareOptions.IgnoreCase) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
if ((Object)a == (Object)b)
{
return(true);
}
if ((Object)a == null || (Object)b == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, 0, a.Length, b, 0, b.Length, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, 0, a.Length, b, 0, b.Length, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
}
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.IgnoreCase) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public Boolean EndsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if (value.Length == 0)
{
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.IsSuffix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.IsSuffix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(this.Length < value.Length ? false : (CompareOrdinalHelper(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
case StringComparison.OrdinalIgnoreCase:
#if FEATURE_COREFX_GLOBALIZATION
return(this.Length < value.Length ? false : (CompareInfo.CompareOrdinalIgnoreCase(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
#else
return(this.Length < value.Length ? false : (TextInfo.CompareOrdinalIgnoreCaseEx(this, this.Length - value.Length, value, 0, value.Length, value.Length) == 0));
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
public static bool Equals(string a, string b, StringComparison comparisonType)
{
if ((object)a == (object)b)
{
CheckStringComparison(comparisonType);
return(true);
}
if ((object)a == null || (object)b == null)
{
CheckStringComparison(comparisonType);
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, GetCaseCompareOfComparisonCulture(comparisonType)) == 0);
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(a, b, GetCaseCompareOfComparisonCulture(comparisonType)) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
#if CORECLR
// If both strings are ASCII strings, we can take the fast path.
if (a.IsAscii() && b.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(a, b));
}
#endif
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public bool Equals(string value, StringComparison comparisonType)
{
if ((object)this == (object)value)
{
CheckStringComparison(comparisonType);
return(true);
}
if ((object)value == null)
{
CheckStringComparison(comparisonType);
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0);
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0);
case StringComparison.Ordinal:
if (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
#if CORECLR
// If both strings are ASCII strings, we can take the fast path.
if (this.IsAscii() && value.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(this, value));
}
#endif
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public Boolean EndsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if (value.Length == 0)
{
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.IsSuffix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.IsSuffix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(this.Length < value.Length ? false : (CompareOrdinalHelper(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
case StringComparison.OrdinalIgnoreCase:
return(this.Length < value.Length ? false : (CompareInfo.CompareOrdinalIgnoreCase(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(OrdinalHelper(span, value, value.Length));
case StringComparison.OrdinalIgnoreCase:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span, value) == 0);
}
Debug.Fail("StringComparison outside range");
return(false);
}
/// <summary>
/// Determines whether this <paramref name="span"/> and the specified <paramref name="value"/> span have the same characters
/// when compared using the specified <paramref name="comparisonType"/> option.
/// <param name="span">The source span.</param>
/// <param name="value">The value to compare with the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="value"/> are compared.</param>
/// </summary>
public static bool Equals(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(span.SequenceEqual(value)); //TODO: Optimize - https://github.com/dotnet/corefx/issues/27487
case StringComparison.OrdinalIgnoreCase:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span, value) == 0);
}
Debug.Fail("StringComparison outside range");
return(false);
}
public bool EndsWith(string value, StringComparison comparisonType)
{
if ((object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if ((object)this == (object)value)
{
CheckStringComparison(comparisonType);
return(true);
}
if (value.Length == 0)
{
CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.InvariantCulture:
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.IsSuffix(this, value, GetCaseCompareOfComparisonCulture(comparisonType)));
case StringComparison.Ordinal:
int offset = this.Length - value.Length;
return((uint)offset <= (uint)this.Length && this.AsSpan(offset).SequenceEqual(value));
case StringComparison.OrdinalIgnoreCase:
return(this.Length < value.Length ? false : (CompareInfo.CompareOrdinalIgnoreCase(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)a == (Object)b)
{
return(true);
}
if ((Object)a == null || (Object)b == null)
{
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
// If both strings are ASCII strings, we can take the fast path.
if (a.IsAscii() && b.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(a, b) == 0);
}
// Take the slow path.
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
#else
return(TextInfo.CompareOrdinalIgnoreCase(a, b) == 0);
#endif
}
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
public bool Equals(String value, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if ((Object)this == (Object)value)
{
return(true);
}
if ((Object)value == null)
{
return(false);
}
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 (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
// If both strings are ASCII strings, we can take the fast path.
if (this.IsAscii() && value.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(this, value) == 0);
}
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
#else
// Take the slow path.
return(TextInfo.CompareOrdinalIgnoreCase(this, value) == 0);
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
}
public static int Compare(String strA, String strB, StringComparison comparisonType)
{
// Single comparison to check if comparisonType is within [CurrentCulture .. OrdinalIgnoreCase]
if ((uint)(comparisonType - StringComparison.CurrentCulture) > (uint)(StringComparison.OrdinalIgnoreCase - StringComparison.CurrentCulture))
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if (object.ReferenceEquals(strA, strB))
{
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
return(-1);
}
if (strB == null)
{
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA.m_firstChar != strB.m_firstChar)
{
return(strA.m_firstChar - strB.m_firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
// If both strings are ASCII strings, we can take the fast path.
if (strA.IsAscii() && strB.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(strA, strB));
}
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
#else
// Take the slow path.
return(TextInfo.CompareOrdinalIgnoreCase(strA, strB));
#endif
default:
throw new NotSupportedException(Environment.GetResourceString("NotSupported_StringComparison"));
}
}
public static int Compare(String strA, int indexA, String strB, int indexB, int length, StringComparison comparisonType)
{
if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase)
{
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), nameof(comparisonType));
}
Contract.EndContractBlock();
if (strA == null || strB == null)
{
if (object.ReferenceEquals(strA, strB))
{
// They're both null
return(0);
}
return(strA == null ? -1 : 1);
}
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), Environment.GetResourceString("ArgumentOutOfRange_NegativeLength"));
}
if (indexA < 0 || indexB < 0)
{
string paramName = indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
if (strA.Length - indexA < 0 || strB.Length - indexB < 0)
{
string paramName = strA.Length - indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
if (length == 0 || (object.ReferenceEquals(strA, strB) && indexA == indexB))
{
return(0);
}
int lengthA = Math.Min(length, strA.Length - indexA);
int lengthB = Math.Min(length, strB.Length - indexB);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CultureInfo.InvariantCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(CompareOrdinalHelper(strA, indexA, lengthA, strB, indexB, lengthB));
case StringComparison.OrdinalIgnoreCase:
#if FEATURE_COREFX_GLOBALIZATION
return(CompareInfo.CompareOrdinalIgnoreCase(strA, indexA, lengthA, strB, indexB, lengthB));
#else
return(TextInfo.CompareOrdinalIgnoreCaseEx(strA, indexA, strB, indexB, lengthA, lengthB));
#endif
default:
throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"));
}
}
