såg en demo på devpartnerprofiler i helgen (från numega/compuware)
den proppsade på att man skulle absolut använda "string.compare" istället för == eller string.equals

kan någon förklara varför det skulle vara bättre på något sätt?

jag kan köpa att den är mer kraftfull på så sätt att man kan kolla sorteringsordning med den.
men om jag nu bara vill jämföra två strängar , varför ska man använda den då???

//Roger

Totalt ovetenskapligt test:

string a="hallaballaa";
string b="hallaballab";
DateTime now=DateTime.Now;
for(int i=0;i<1000000;i++)
{
	if(String.Compare(a,b)==0)Console.WriteLine("fishy");//alt 1
	//if(a==b)Console.WriteLine("fishy");//alt 2
}
Console.WriteLine("Elapsed {0}",DateTime.Now-now);

Console.WriteLine(String.Compare("Ö","û").ToString());
Thread.CurrentThread.CurrentCulture=CultureInfo.CreateSpecificCulture("DE-de");
Console.WriteLine(String.Compare("Ö","û").ToString());

Med risk för att göra bort mig, men är det inte så att Compare verkligen jämför strängarna medans Equal kollar om de pekar på samma minnesadress (det vill säga att det är SAMMA objekt). Eftersom strängar är immutable i .Net så lagras varje unik sträng endast en gång i en pool som kallas Intern Pool även om tio olika strängvariabler "innehåller" en viss sträng. Därför är givetvis Equals mycket snabbare än Compare...

Jag är lite osäker på det här men har för mig att det fungerade så...

Kolla i hjälpen på propertyn String.IsInterned samt metoden String.Intern, där finns lite info om hur stränghanteringen och Intern Pool fungerar.

men varför skulle devpartners profiler pusha för att använda string.compare då?
det verkar ju bara helt korkat.

"use string.compare to get slower code , more code , and less readable code" ;-)

jag köper argumentet med att den kan jämföra globalizerade saker annorlunda än == eller equals.

men men.

någon som har lite info om == och .Equals oxo?

.Equals och == ger tydligen inte heller samma prestanda enlgit div mätningar.

varför är det så och vilken är den man _bör_ använda?

//Roger

jo det verkar som du har rätt hultan men det är fortfarande skillnad på Equals och CompareTo
om man kör följande:

string a="a";
string b="b";
string c="hallaballa";

DateTime now=DateTime.Now;

for(int i=0;i<1000000;i++)
{
	
	if(String.Compare(c+a,c+b)==0)Console.WriteLine("fishy");
	//if(c+a==c+b)Console.WriteLine("fishy");
}

TimeSpan ret=DateTime.Now-now;
Console.WriteLine(String.IsInterned(c+a)==null);
Console.WriteLine("Elapsed {0}",ret);

För er som är nyfikna på implementationen av Equals,Compare och CompareTo kan ta en titt på koden nedan.

String:

<code>
public static bool Equals(string a, string b)
{ if (a == b)
{
return true;
}
if ((a == null) || (b == null))
{
return false;
}
return a.Equals(b);
}
</code>


<code>
public int CompareTo(string strB)
{ if (strB == null)
{
return 1;
}
return CultureInfo.CurrentCulture.CompareInfo.Compare(this, strB, 0);
}
</code>

<code>
public static int Compare(string strA, string strB)
{ return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, 0);
}
</code>

CultureInfo.CurrentCulture.CompareInfo:

<code>
public virtual int Compare(string string1, string string2, CompareOptions options)
{ return CompareInfo.Compare(this.pSortingTable, this.win32LCID, string1, string2, options);
}
</code>

/Fredrik Normén NSQUARED2
http://normen.mine.nu/myblog

hmm , då till nästa fråga.
om equals har implementerats som:

public static bool Equals(string a, string b)
<b>{ if (a == b)
{
return true;
}</b>
if ((a == null) || (b == null))
{
return false;
}
return a.Equals(b);
}

så görs det ju onekligen en == jämförelse där.
varför är det då långsammare att använda == än .equals om .equals iaf använder == ??


//Roger

För att String har operatorn == överlagrad:

<code>
public static bool operator == (String a, String b) {
return String.Equals(a, b);
}
</code>

Och det som som görs i Equals är:

if( (object)a == (object)b )

/Fredrik Normén NSQUARED2
http://normen.mine.nu/myblog

fast då borde ju prestandan alltid vara bättre på .equals
nu är ju prestandan mellan .equals och == olika beroende på om stängarna är lika eller olika

och prestandan borde ju bara vara _lite_ bättre på .equals än på ==
nu är den ju typ dubbelt så snabb på vissa saker

//Roger