Combien coûte un GUID de fonte et de comparaison vs une comparaison de chaîne

qui serait plus rapide?

bool same=(Guid)Identifier==id;

bool same=String.Equals(string1,string2, StringComparison.OrdinalIgnoreCase);
ce n'est pas facile suffisant pour tester?
semblable (mais pas le même) question ici stackoverflow.com/questions/713109/...
Lorsque, jamais, serait-il? Cela sonne comme un cas de micro-optimisation, ce qui devrait être évité à tout prix. Rappelez-vous, tout d'abord le faire le travail, que (si nécessaire) le rendre plus rapide.

OriginalL'auteur zsharp | 2010-01-22

  1. 27

    J'ai utilisé ce code:

    object victim = Guid.Empty;
Guid target = Guid.NewGuid();

Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000000; i++){
    bool equal = ((Guid) victim) == target;
}
Console.WriteLine("Direct cast   : {0}", sw.Elapsed);

sw.Reset(); sw.Start();
for (int i = 0; i < 10000000; i++)
{
    bool equal = Guid.Equals(victim, target);
}
Console.WriteLine("Guid.Equals   : {0}", sw.Elapsed);

sw.Reset(); sw.Start();
string a = victim.ToString(); //as suggested by Mikael
string b = target.ToString();
for (int i = 0; i < 10000000; i++)
{
    bool equal = String.Equals(a, b, StringComparison.OrdinalIgnoreCase);
}
Console.WriteLine("String.Equals : {0}", sw.Elapsed);

Console.ReadLine();

    Et obtenu ce résultat pour différentes valeurs (meilleur scénario):

    object victim = Guid.Empty;
Guid target   = Guid.NewGuid();
//Direct cast   : 00:00:00.1164198
//Guid.Equals   : 00:00:02.1268147
//String.Equals : 00:00:00.4129527  //oh my!

    Et ce résultat pour la même valeur (pire scénario)

    object victim = Guid.Empty;
Guid target   = Guid.Empty;
//Direct cast   : 00:00:00.2793173
//Guid.Equals   : 00:00:03.5625948
//String.Equals : 00:00:01.7564302
    c'est la meilleure réponse, car elle montre, en réalité, une référence...
    Votre indice de référence des sorties comparaison octet 1 qui est le meilleur effort. Si l'on compare même plus d'octets à la fois serait différente même plus. Mais le temps diff n'est pas aussi grand que vous, puisque vous avez inclus la .ToString() dans la boucle. string a = victime.ToString(); string b = cible.ToString(); for (int i = 0; i < 10000000; i++) { bool égal = Chaîne de caractères.Est égal à(a, b, StringComparison.OrdinalIgnoreCase); }
    conseils sympas; votre suggestion conduire une énorme amélioration sur la chaîne.est égal à la performance.

    OriginalL'auteur Rubens Farias

  2. 11

    Dans mes essais de faire un tout droit UUID UUID comparaison VS string-Chaîne de comparaison, l'UUID de la comparaison prend environ 1/4 du temps comme la comparaison de chaînes de caractères.

    Cependant, le casting de la Chaîne->UUID est cher. Beaucoup plus cher que l'UUID->conversion de Chaîne de caractères. Les deux sont plus coûteuses que les méthodes de comparaison.

    Donc:
    Si vous avez deux Uuid de comparer les Uuid directement.
    Si vous avez deux Chaînes de comparer les Chaînes de caractères directement.
    Si vous avez une Chaîne et un UUID, convertir l'UUID d'une Chaîne et de comparer les Chaînes de caractères.

    OriginalL'auteur Michael Krauklis

  3. 1

    Un Guid == Guid va utiliser un code comme:

    public bool Equals(Guid g)
{
if (g._a != this._a)
{
    return false;
}
if (g._b != this._b)
{
    return false;
}

    tandis que la chaîne de comparer à votre exemple, nous utiliserons un dangereux pointeur de la comparaison.

    Sans benchmarking, je soupçonne le Guid sera plus rapide, mais nous parlons marginal. Et vous avez vraiment besoin de pousser le nombre de comparaisons à plusieurs millions pour elle à la matière.

    À la fois des comparaisons de break dès le début, le sens de gauche à droite, de sorte qu'aura également un impact sur la vitesse. La comparaison de chaîne a plus de vérifications avant la comparaison et l'autre plus de l'appel de la méthode.

    ce qui le rend plus sûr?
    il a dit que plus vite, pas plus sûr, même si je serais curieux de voir comment la casse de la chaîne de comparaison pourrait utiliser un indicateur de comparaison.
    Le "dangereux" mot clé n'est pas nécessairement dangereux à utiliser, mais il vous permet d'utiliser la mémoire de pointeurs comme en C++. De nombreuses fonctions dans le .Net framework sont mises en œuvre de cette façon. Donc, les deux façons sont également sûrs à utiliser 🙂 je me suis contenté de se référer à la fonction réelle dans le cadre de private static dangereux int CompareOrdinalIgnoreCaseHelper(chaîne de strA, chaîne ampb)
    Robinson découvrez private static dangereux int CompareOrdinalIgnoreCaseHelper(chaîne de strA, chaîne ampb) avec réflecteur et ils utilisent des pointeurs de char et de l'ints.

    OriginalL'auteur Mikael Svenson

  4. 1

    Un GUID compare est un comparateur de mémoire de 16 octets. Il ne va pas être pire de pire qu'une chaîne de comparer, mais si vous vous souciez de la performance que beaucoup vous ne devriez pas utiliser du code managé.

    Sa chaîne de comparaison est sensible à la casse. Tandis que la comparaison ne devrait pas être très différent en termes de temps, ce n'est pas un octet-par-octet de comparaison comme un Guid serait.
    Il n'est pas. L' .Net guid se compose de Int32+Int16+Int16+(octets*8). Et il compare l'un contre l'autre jusqu'à ce que le dernier octet. Sens un max de 11 comparaisons.
    Code managé est en fait assez rapide - environ 25 à 50% plus lent que C++ dernière, j'ai vérifié, environ le même que Java... comparer avec 8,000% de plus pour Python/Ruby, et 50 000% plus lent pour PHP...
    Il ne peut pas être plus rapide, le code managé est son propre univers, afin de toucher tout réel des fichiers, internet, etc, vous devez vous quitter de code managé. Mieux de rester en dehors du domaine d'application, en premier lieu, si vous avez besoin du maximum absolu de la performance.
    Faut-il vraiment faire 11 comparaisons? Cela se fait en 4 comparaisons dans le code non managé, et sans l'aide d'un appel de fonction si memcmp a une valeur intrinsèque.

    OriginalL'auteur John Knoeller

  5. 1

    .NET Guid est de 16 octets de la structure qui représenté comme une chaîne de caractères sera formatée dans ce modèle "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", qui est d'environ 32 caractères.

    Ainsi représenté comme un GUID, il faudrait de 16 octets, et
    représenté comme une chaîne, il prendrait 32*2 = 64 octets.

    Donc GUID.Equals() devrait faire mieux.

    Aussi GUID.Equals(GUID) plus performant alors guid1 == guid2 car il n'est pas de la boxe impliqué dans l'ancien.

    Guid.Equals(object, object) de sorte que vous aurez des nations unies/de boxe en cause; s'il vous plaît, voir mon test là-haut
    Guid.Equals(Guid) qui est décrit ici. msdn.microsoft.com/en-us/library/asw89aw8.aspx. Regarde comme il n'y a pas de boxe impliqués pour cette surcharge.
    oh désolé, je pensais que vous parlez de la version statique; mais, de toute façon, vous aurez besoin d'utiliser Guid.Equals(object) en tant que point de l'ensemble est sur le casting de l'objet
    Mon test rapide montre que le Guid.Equals(object, object) est sacrément lent. En fait, il est environ 5 FOIS plus lent que guid1 == guid2. La manière la plus rapide que j'ai trouvé est guid1.Equals(guid2). C'est 20% plus rapide que le plan de vieux - ==

    OriginalL'auteur Santhosh