c # Le moyen le plus rapide de comparer les chaînes

Chaîne de caractères.Opérateur D'Égalité ou == appelle en interne string.Equalsafin de l'utiliser string.Égal à ou == fournies par le framework. Il est déjà assez optimisé.

Il d'abord à comparer les références, puis de la longueur, puis des caractères réels.

Vous pouvez trouver le code source ici

Code: (Source: http://www.dotnetframework.org/default.aspx/4@0/4@0/DEVDIV_TFS/Dev10/Releases/RTMRel/ndp/clr/src/BCL/System/String@cs/1305376/String@cs)

//Determines whether two strings match.
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public override bool Equals(Object obj) {
    if (this == null)                        //this is necessary to guard against reverse-pinvokes and
        throw new NullReferenceException();  //other callers who do not use the callvirt instruction

    String str = obj as String;
    if (str == null)
        return false;

    if (Object.ReferenceEquals(this, obj))
        return true;

    return EqualsHelper(this, str);
}

et

[System.Security.SecuritySafeCritical]  //auto-generated
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private unsafe static bool EqualsHelper(String strA, String strB)
{
Contract.Requires(strA != null);
Contract.Requires(strB != null);
int length = strA.Length;
if (length != strB.Length) return false;
fixed (char* ap = &strA.m_firstChar) fixed (char* bp = &strB.m_firstChar)
{
char* a = ap;
char* b = bp;
//unroll the loop
#if AMD64
//for AMD64 bit platform we unroll by 12 and
//check 3 qword at a time. This is less code
//than the 32 bit case and is shorter
//pathlength
while (length >= 12)
{
if (*(long*)a     != *(long*)b) break;
if (*(long*)(a+4) != *(long*)(b+4)) break;
if (*(long*)(a+8) != *(long*)(b+8)) break;
a += 12; b += 12; length -= 12;
}
#else
while (length >= 10)
{
if (*(int*)a != *(int*)b) break;
if (*(int*)(a+2) != *(int*)(b+2)) break;
if (*(int*)(a+4) != *(int*)(b+4)) break;
if (*(int*)(a+6) != *(int*)(b+6)) break;
if (*(int*)(a+8) != *(int*)(b+8)) break;
a += 10; b += 10; length -= 10;
}
#endif
//This depends on the fact that the String objects are
//always zero terminated and that the terminating zero is not included
//in the length. For odd string sizes, the last compare will include
//the zero terminator.
while (length > 0)
{
if (*(int*)a != *(int*)b) break;
a += 2; b += 2; length -= 2;
}
return (length <= 0);
}
}

Selon ILSpy, la chaîne == opérateur est défini comme:

public static bool operator ==(string a, string b)
{
return string.Equals(a, b);
}

Qui est définie comme

public static bool Equals(string a, string b)
{
return a == b || (a != null && b != null && a.Length == b.Length && string.EqualsHelper(a, b));
}

Je suppose que la première a == b est en fait une référence de contrôle d'égalité (ILSpy est juste rendu comme ==), sinon ce serait infiniment méthode récursive.

Cela signifie que == déjà de vérifier les longueurs des cordes avant de comparer leurs personnages.

Pour les geeks d'entre nous, voici une page qui fait un excellent travail à l'analyse comparative de nombreux moyens pour comparer des chaînes.

En un mot, la méthode la plus rapide semble être le CompareOrdinal:

if (string.CompareOrdinal(stringsWeWantToSeeIfMatches[x], stringsWeAreComparingAgainst[x]) == 0)
{
//they're equal
}

Le deuxième meilleur moyen semble être l'utilisation d'un Dictionnaire ou Hashset avec la "clé" que la chaîne de caractères que vous souhaitez comparer.

En fait une lecture intéressante.

Donc, comme je l'ai promis, j'ai écrit un petit code avec un chronomètre - vous pouvez copier coller et essayer sur différentes chaînes et de voir les différences

class Program
{
static void Main(string[] args)
{
string str1 = "put the first value";
string str2 = "put the second value";
CompareTwoStringsWithStopWatch(str1, str2); //Print the results.
}
private static void CompareTwoStringsWithStopWatch(string str1, string str2)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 99999999; i++)
{
if (str1.Length == str2.Length && str1 == str2)
{
SomeOperation();
}
}
stopwatch.Stop();
Console.WriteLine("{0}. Time: {1}", "Result for: str1.Length == str2.Length && str1 == str2", stopwatch.Elapsed);
stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < 99999999; i++)
{
if (str1 == str2)
{
SomeOperation();
}
}
stopwatch.Stop();
Console.WriteLine("{0}. Time: {1}", "Result for: str1 == str2", stopwatch.Elapsed);
}
private static int SomeOperation()
{
var value = 500;
value += 5;
return value - 300;
}
}

Mes conclusions:

1. Comme je l'ai vérifié certaines chaînes (courtes et longues), j'ai vu que tous les résultats sont presque les mêmes. Ainsi, le premier cas (avec le contrôle de la longueur) est plus lente dans les 2/3.
2. Et vous avez une méthode Equals de la classe de l'Objet, il suffit d'utiliser 🙂
3. Vous pouvez l'essayer et nous donner les résultats 🙂