0, foran text i text box.

Bahhh.. Jeg  er så træt!!! glemte .Text


private void button1_Click(object sender, EventArgs e)
        {

            tbPris1.Text = "0," + tbRabat1.Text;

        }

Du bør skrive det sådan her.

private void button1_Click(object sender, EventArgs e)
{
  tbPris1.Text = string.Format("0,{0}",tbRabat1.Text);
}

kalp >>

Hvad skulle argumentet være for det?.

I den her situation:
Performance: Concat er bedre (fordi der kun er 2 elementer der concatineres)
Pænere kode: Smagssag, Personligt er jeg helt pjattet med string.Format, men det er en holdning.
Maintainability: Format, men MED en IFormatProvider

argumentet er de bøger du læser som anbefaler man gør sådan eller benytter StringBuilder i størrer sammenlægninger.

man kan ligeså godt gøre det på den rigtige måde selv om situationen her måske virker ligegyldigt, men det er godt at gøre sådan noget til en vane.

Husk på, at hvis det drejede sig om følgende

string test = "hej";
test += " med";
test += " dig";

så laves der 3 stk. test objekter.. hvor den gamle bliver spist af garbage collector når den når så langt.

Jeg laver ofte javascript fra codebehind som kan blive ret store og der betyder det MEGET om jeg skriver += for hver linje eller benytter en StringBuilder til jobbet..

String.Format skulle så vidt jeg husker heller ikke lave en ny kopi.

Det er rigtig at StringBuilder er bedre ved stører sammenlægninger.
Ligeledes er det rigtigt at string.Format bruger en StringBuilder under hjælmen.

Men det er forkert at tro at den derfor er bedre end Concat. tværtimod.
Concat performer typisk bedre ved inline asigns, ligemeget hvor mange concats der er. ex:

string test = "1"+2+"1"+2+"1"+2+"1"+2+"1"+2+"1"+2+"1"+2;

fordi at den benytter string.Concat( object[] args );, som under hjælmen ligsom også er optimeret.

Der hvor filmen knækker vil være:
string test = "1"+2; // 3 strings i spil
test += "1"+2; // 6 strings i spil
test += "1"+2; // 9 strings i spil
test += "1"+2; // 12 strings i spil
test += "1"+2; // 18 strings i spil
test += "1"+2; // 21 strings i spil
test += "1"+2; // 24 strings i spil

Og tilsvarende er:

string test =string.Format("{0}{1}","1",2); // 4 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 8 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 12 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 16 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 20 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 24 strings i spil
test =  string.Format("{0}{1}{2}",test,"1",2); // 28 strings i spil

Kun endnu væere...
Det er her er en StringBuilder er langt bedre... da test ikke igen og igen allokeres på heapen.
som den ellers gør med de to overstående eksempler.

Derfor er det forkert at tro at string.Format på nogen måde er bedre end Concat når det kommer til performance.
Det er IMO pænere at bruge og mere overskueligt når det bliver til mange elementer. men det har sit drawback
at man samtidig allokere en stringbuilder hvis det ikke er nødvendigt.

Så derfor skal man stadig bruge en StringBuilder når man har brug for at bygge en streng langsomt op, mens det er unødvendigt ved inline asignments.

Kan da lige poste: http://www.codeproject.com/Purgatory/string.asp

og understrege: Last week I show a person, who used StringBuilder to just add two strings together! its really nonsense.

Jeg har ikke sagt på noget tidspunkt, at Concater forkert - den er også korrekt.

Men hvor står der, at string test = "hej" + "dig";

laver Concat i baggrunden?

den teori udelader de tilsyneladende i de fleste bøger, men vil gerne se det - ikke at jeg siger du lukker luft ud nu, men vil gerne læse det.

Nu er hej med dig jo et super kedeligt eksempel for det vil svare til:

string test = string.Format( "{0}{1}", "hej", "dig" );

og vi kan jo alle se at der allokeres:

string 1: "hej"
string 2: "dig"
string 3: test ("hejdig")
(og i formats tilfælde også lige "{0}{1}")

et mere interessant eksempel:

string test = "1" + "2" + "3" + "4" + "5";
string test = string.Format( "{0}{1}{2}{3}{4}","1","2","3","4","5");

er nok mere interassant at kigge på?
det er nemt at se at begge tilfælde alokere stregene 1-5, og så self "12345" (test) samt format har en "{0}{1}{2}{3}{4}".

men hvad sker der under neden?... ja format alokere jo de 7 strenge... 1-5 (det er 5) + test (6) og så format strengen det er 7... enig?

hvad gør concat så?

nogle kunne måske tro at den gør det samme som:
string test = "1" + "2";
test += "3";
test += "4";
test += "5"

altså først 1 og 2, samt 12, så 3 og 123, så 4 og 1234 og så 5 og 12345. det var mange. 9 i alt... men det er heldigvis ikke det der sker.

concat får nemlig 1-5 ind i et array af strings (eller objecter hvis det ikke er rent strings).

herfra går den dem alle igennem og lægger deres længde sammen... efter det gør den faktisk det samme som der sker i en StringBuilder når du kalder Append.

Concat:

public static string Concat(params object[] args)
{
    if (args == null)
    {
        throw new ArgumentNullException("args");
    }
    string[] values = new string[args.Length];
    int totalLength = 0;
    for (int i = 0; i < args.Length; i++)
    {
        object obj2 = args[i];
        values[i] = (obj2 == null) ? Empty : obj2.ToString();
        totalLength += values[i].Length;
        if (totalLength < 0)
        {
            throw new OutOfMemoryException();
        }
    }
    return ConcatArray(values, totalLength);
}

ConcatArray:

private static string ConcatArray(string[] values, int totalLength)
{
    string dest = FastAllocateString(totalLength);
    int destPos = 0;
    for (int i = 0; i < values.Length; i++)
    {
        FillStringChecked(dest, destPos, values[i]);
        destPos += values[i].Length;
    }
    return dest;
}

FillStringChecked:
private static unsafe void FillStringChecked(string dest, int destPos, string src)
{
    int length = src.Length;
    if (length > (dest.Length - destPos))
    {
        throw new IndexOutOfRangeException();
    }
    fixed (char* chRef = &dest.m_firstChar)
    {
        fixed (char* chRef2 = &src.m_firstChar)
        {
            wstrcpy(chRef + destPos, chRef2, length);
        }
    }
}


Og StringBuilders AppendInPlace:

internal unsafe void AppendInPlace(string value, int currentLength)
{
    int length = value.Length;
    int index = currentLength + length;
    fixed (char* chRef = &this.m_firstChar)
    {
        fixed (char* chRef2 = &value.m_firstChar)
        {
            wstrcpy(chRef + currentLength, chRef2, length);
        }
        chRef[index] = '\0';
    }
    this.m_stringLength = index;
}

En lille opklaring.

C# compileren optimerer altså en smule.

string s = "a" + "b" + "c";

giver samme IL kode som:

string s = "abc";

så længe det er ene literal strings, så er er der ingen runtime overhead overhovedet.

Det er først med variable og literals af andre typer at der sker noget runtime.