String.comparison Performances (avec garniture)

1. La chose est, si cela doit être fait, cela doit être fait. Je ne pense pas que l'une de vos différentes solutions fera une différence. Dans chaque cas, il doit y avoir un certain nombre de comparaisons pour trouver le blancheur ou le retirer.

   Apparemment, l'élimination de la blanchie fait partie du problème, de sorte que vous ne devriez pas vous inquiéter de cela.

2. et la réduction de la chaîne d'une chaîne Avant de comparer, est un bogue si vous travaillez avec des caractères unicode et éventuellement plus lent que la copie d'une chaîne.

Les avertissements concernent l'optimisation prématurée sont corrects, mais je suppose que vous avez testé cela et constaté que beaucoup de temps sont en train de gaspiller des cordes. Dans ce cas, j'essaierais ce qui suit:

static void FindStartAndLength(string text, out int startIndex, out int length)
{
    startIndex = 0;
    while(char.IsWhiteSpace(text[startIndex]) && startIndex < text.Length)
        startIndex++;

    length = text.Length - startIndex;
    while(char.IsWhiteSpace(text[startIndex + length - 1]) && length > 0)
        length--;
}

Quelque chose comme ça devrait le faire: xxx

exemple: xxx

sortie: xxx

Vous devriez le profiler contre une simple garniture et comparer avec quelques données réelles, pour voir s'il y a vraiment une différence pour ce que vous allez l'utiliser pour.

Vous pouvez implémenter votre propre stringcomparer code>. Voici une implémentation de base:

public class TrimmingStringComparer : StringComparer
{
    private StringComparison _comparisonType;

    public TrimmingStringComparer()
        : this(StringComparison.CurrentCulture)
    {
    }

    public TrimmingStringComparer(StringComparison comparisonType)
    {
        _comparisonType = comparisonType;
    }

    public override int Compare(string x, string y)
    {
        int indexX;
        int indexY;
        int lengthX = TrimString(x, out indexX);
        int lengthY = TrimString(y, out indexY);

        if (lengthX <= 0 && lengthY <= 0)
            return 0; // both strings contain only white space

        if (lengthX <= 0)
            return -1; // x contains only white space, y doesn't

        if (lengthY <= 0)
            return 1; // y contains only white space, x doesn't

        if (lengthX < lengthY)
            return -1; // x is shorter than y

        if (lengthY < lengthX)
            return 1; // y is shorter than x

        return String.Compare(x, indexX, y, indexY, lengthX, _comparisonType);
    }

    public override bool Equals(string x, string y)
    {
        return Compare(x, y) == 0;
    }

    public override int GetHashCode(string obj)
    {
        throw new NotImplementedException();
    }

    private int TrimString(string s, out int index)
    {
        index = 0;
        while (index < s.Length && Char.IsWhiteSpace(s, index)) index++;
        int last = s.Length - 1;
        while (last >= 0 && Char.IsWhiteSpace(s, last)) last--;
        return last - index + 1;
    }
}

• Il n'est pas testé de manière approfondie et pourrait contenir des bugs li>
• Les performances doivent encore être évaluées (mais c'est probablement mieux que d'appeler Cadmin code> et tolower code> de toute façon) li>
• La méthode gethashcode code> n'est pas implémentée, alors ne l'utilisez pas comme une touche dans un dictionnaire li> ul> p>

Je remarque que votre première suggestion ne compare que pour l'égalité plutôt que pour le tri, qui permet d'économiser d'autres économies d'efficacité.

public static int TrimmedOrdinalIgnoreCaseHashCode(string str)
{
    //Higher CMP_NUM (or get rid of it altogether) gives
    //better hash, at cost of taking longer to compute.
    const int CMP_NUM = 12;
    if(str == null)
        return 0;
    int start = 0;
    int end = str.Length;
    while(start != end && char.IsWhiteSpace(str[start]))
        ++start;
    if(start != end)
        while(char.IsWhiteSpace(str[end - 1]))
            --end;

    int skipOn = (end - start) / CMP_NUM + 1;
    int ret = 757602046; // no harm matching native .NET with empty string.
    while(start < end)
    {
            //prime numbers are our friends.
        ret = unchecked(ret * 251 + (int)(char.ToLowerInvariant(str[start])));
        start += skipOn;
    }
    return ret;
}