public static void Main(string[] args)
{
var summary = BenchmarkRunner.Run <IntroBenchmarkBaseline>();
Console.WriteLine("Result: {0}", SimpleCaseFolding.SimpleCaseFold("cASEfOLDING2"));
Console.WriteLine("Result: {0}", SimpleCaseFolding.SimpleCaseFold("яЯяЯяЯяЯяЯя2"));
}
private static int GetHashCodeSimpleCaseFolding(string source)
{
Debug.Assert(source != null, "source must not be null");
// Do not allocate on the stack if string is empty
if (source.Length == 0)
{
return(source.GetHashCode());
}
char[] borrowedArr = null;
Span <char> destination = source.Length <= 255 ?
stackalloc char[source.Length] :
(borrowedArr = ArrayPool <char> .Shared.Rent(source.Length));
SimpleCaseFolding.SimpleCaseFold(source, destination);
int hash = String.GetHashCode(destination);
// Return the borrowed array if necessary.
if (borrowedArr != null)
{
ArrayPool <char> .Shared.Return(borrowedArr);
}
return(hash);
}
/// <summary>
/// IComparer.Compare() implementation.
/// </summary>
/// <param name="x">Object to compare.</param>
/// <param name="y">Object to compare.</param>
/// <returns>
/// Returns 0 - if equal, -1 - if x < y, +1 - if x > y.
/// </returns>
public int Compare(object x, object y)
{
if (x == y)
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
if (x is string sa && y is string sb)
{
return(SimpleCaseFolding.CompareUsingSimpleCaseFolding(sa, sb));
}
if (x is IComparable ia)
{
return(ia.CompareTo(y));
}
throw new ArgumentException("SR.Argument_ImplementIComparable");
}
/// <summary>
/// IEqualityComparer<string>.Equals() implementation.
/// </summary>
/// <param name="x">Left object to compare.</param>
/// <param name="y">Right object to compare.</param>
/// <returns>
/// Returns true if equal.
/// </returns>
public bool Equals(string x, string y)
{
if (object.ReferenceEquals(x, y))
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
return(SimpleCaseFolding.CompareUsingSimpleCaseFolding(x, y) == 0);
}
/// <summary>
/// IComparer<string>.GetHashCode() implementation.
/// </summary>
/// <param name="x">Left object to compare.</param>
/// <param name="y">Right object to compare.</param>
/// <returns>
/// Returns 0 - if equal, -1 - if x < y, +1 - if x > y.
/// </returns>
public int Compare(string x, string y)
{
if (object.ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
return(SimpleCaseFolding.CompareUsingSimpleCaseFolding(x, y));
}
private static unsafe int ComputeHash32OrdinalIgnoreCaseSlow(ref char data, int count, uint p0, uint p1)
{
Debug.Assert(count > 0);
char[] borrowedArr = null;
Span <char> scratch = (uint)count <= 64 ? stackalloc char[64] : (borrowedArr = ArrayPool <char> .Shared.Rent(count));
SimpleCaseFolding.SimpleCaseFold(new ReadOnlySpan <char>(Unsafe.AsPointer(ref data), count), scratch);
// Slice the array to the size returned by ToUpperInvariant.
// Multiplication below may overflow, that's fine since it's going to an unsigned integer.
int hash = ComputeHash32(ref Unsafe.As <char, byte>(ref MemoryMarshal.GetReference(scratch)), count * 2, p0, p1);
// Return the borrowed array if necessary.
if (borrowedArr != null)
{
ArrayPool <char> .Shared.Return(borrowedArr);
}
return(hash);
}
public char CharFold(char c)
{
return(SimpleCaseFolding.SimpleCaseFold1(c));
}
public string SimpleCaseFold(string StrA)
{
return(SimpleCaseFolding.SimpleCaseFold(StrA));
}
public char SimpleCaseFoldTest()
{
return(SimpleCaseFolding.SimpleCaseFoldTest(TestChar));
}
