// 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")); } }