I vb6 kunde jag skriva...

MsgBox("ngn sträng" & vbCrLf & "en till sträng")


men hur använder jag mig av en Cr ( eller en new line ) i vb.net ?
finns det någon konstant liknande vbCrLf eller måste jag kalla på stäng objektets NewLine funktion ?

//Mooosie

Svar 1:
I detta fall kan du i VB.NET skriva precis som du gjorde i VB6.

Svar 2:
Men ett mer .nettigt svar är att du kan använda MessageBox.Show samt Environment.NewLine.

<code>
MsgBox("hej" + vbCrLf + "hopp")
MessageBox.Show("hej" + Environment.NewLine + "hopp")
MessageBox.Show("hej" + vbCrLf + "hopp")
</code>

En observation jag gjorde när jag kollade på IL-koden för detta var att "vb6-koden" faktiskt var en liten aaaaaning effektivare. Detta genom att vbCrLf översätts av kompilatorn till "\r\n" medan Env.NewLine blir ett propertyanrop. Kan vara bra att tänka på om man gör någon prestandakritiskt i t.ex. en loop.

Jag tror att jag skulle behålla vbCrLf även om jag skrev vb.net, men det är en högst personlig åsikt och ingen officiell rekommendation. Däremot bör du nog använda dig av MessageBox.Show för att inte fastna i VB6 kod, det gör det enklare för dig den dag du blir tvungen att skriva .NET program i C#, Smalltalk, etc. eftersom du använder .NET klasserna direkt och inte någon wrapper runt dem.

/Mattias

OBS! Rekommendationen nedan rekommenderar jag enbart om man har tänkt bygga en platforms oberoende applikation.

Jag skulle inte använda mig av vbCrLf. Som Mattias sa så ser man i IL att vbCrLf blir "\r\n". Mattias pratar lite om prestanda i loopar och självklart går vbCrLf fortare än att använda Environment.NewLine. Men det beror självklart på hur man skriver looparna. En loop som ser ut:

<code>
for i = 0 to 2000000
myString = vbCrlf
next i
</code>

Går ca: 20 Msec snabbare än:

<code>
for i = 0 to 2000000
myString = Environment.NewLine
next i
</code>

Men jag skulle inte rekommendera att skriva en loop på det sättet.
Jag skulle undvika vbCrLf och istället skriva:

<code>
Dim newLine as String
newLine = Environment.NewLine

for i = 0 to 2000000
myString = newLine;
next i
</code>

Om man i loopen anropar newLine eller VbClrf flera gånger, alltå har en sträng där man ska lägga till ny rad flera gåner under loopen så går koden ovan lika fort som att skriva vbCrLf. Det går åt en liten liten msec att utföra newLine = Environment.NewLine men det handlar om en sådan liten tid så det inte kommer att vara märkbart.

Nu till varför jag inte rekommenderar att använda vbCrLf. Jo vbCrlf är en sträng konstant som har värdet "\r\n". Environment.NewLine returnerar olika newline strängar beroende platform. Detta innebär att om man i framtiden ska porta sin .Net lösning till tex Unix eller Mac etc så kommer man få rätt newline sträng för respektive platform. Men använder man vbCrlf så få man inte det och saker och ting kan bli fel.

Om vi tar en titt på hur System.Environment.NewLine är implmenterad av Microsoft så ser koden ut:

<code>
public static String NewLine {
get {
#if !PLATFORM_UNIX
return "\r\n";
#else
return "\n";
#endif // !PLATFORM_UNIX
}
}
</code>

Här ser vi att UNIX har "\n" och inte "\r\n". System.Environment.NewLine följer med i CLI och det innebär att när du kör din kod på en annan platform så kommer NewLine att returnera den newline sträng som motsvara en ny rad på respektive platform.

/Fredrik N

En liten parantes som inte betyder så mkt, men kanske är det kul vetande?

<code>
#else
return "\n";
</code>
Kommer bara att utföras om MS själva satt sin Conditional Compilation Contants till PLATFORM_UNIX. MS egna CLI implementation ser alltså ut att bara fungera under Windows samt ev Unix. (Andra CLI:er har ju självklart sin implementation av denna metod)
Dock räcker det att man i sin kod använder namespaces som inte är en direkt CLI standard. Då spelar det ingen större roll om man använder NewLine eller för hand skriver ex "\r\n" Är man dock nogran med sin impelementation och delar upp sin arkitektur i olika lager m.m där man ex byggt enga classer som lätt går att byta ut beroende på platform så är ju NewLine ett bra val.

Mono (linux cli implementation) Verkar använda sig av reflection vid anrop mot NewLine, vilket då påverka prestandan negativt.

//Johan N

Jag tackar er båda för de utförliga svaren.

Mitt "problem" är nu löst, dock inser jag att det kan vara läge att fundera på vilken metod som är bäst i andra fall, tex när man jobbar med textfiler osv...


//Mooosie

Rätt resonemang runt multi-platform, även om jag nog själv inte skulle ta hänsyn till det när jag utvecklar... Men jag är ju ganska fast på MS platformen :-)

Men jag håller inte med om perf resonemanget. Gjorde egna tester som faktiskt gjorde något också, inte bara tilldelade. Och förresten så fick jag inte samma tider som dig.

<code>
For i = 0 To 2000000
' s = vbCrLf ' 8 ms
' s = Environment.NewLine ' 9 ms
's = "hej" + vbCrLf + "hopp" ' 8 ms
s = "hej" + Environment.NewLine + "hopp" ' 722 ms
Next
</code>

Men ännu mer realtistiskt är faktiskt som nedan, alltså att man successivt bygger upp en sträng genom att slå ihop stängar. Så ett realistiskt exempel visar att det inte spelar någon roll. Men nu 2000 iteration pga tidsåtgång.

<code>
For i = 0 To 2000
' s += "hej" + vbCrLf + "hopp" ' 190-200 ms
s += "hej" + Environment.NewLine + "hopp" ' 190-200 ms
Next
</code>

MEN, det är ju inte optimalt eftersom man ska använda StringBuilder, tillbaka till 2000000 iterationer... Och se! Då verkar det gå snabbare att använda Environment.NewLine...

<code>
' 2000 ms
For i = 0 To 2000000
sb1.Append("hej")
sb1.Append(vbCrLf)
sb1.Append("hopp")
Next

' 1950 ms
For i = 0 To 2000000
sb1.Append("hej")
sb1.Append(Environment.NewLine)
sb1.Append("hopp")
Next
</code>

Sammanfattningsvis kan man nog säga att ur prestanda perspektiv så spelar det ingen roll, om man inte gör något som är extremt prestanda känsligt.

/Mattias

Jag är rätt nyfiken hur kompilatorn better sig i dessa fall. Känner den av att NewLine kommer att utföras x antal ggr och på så vis lägger den till dess värde i cachen? Eller kommer den att anropas 2000 ggr om man har en loop på 2000ggr?
Antar att den hanteras under runtime?

Skulle villja se en test på detta oxå:
<code>
newline = Environment.NewLine
For i = 0 To 2000000
sb1.Append("hej")
sb1.Append(newline)
sb1.Append("hopp")
Next
</code>

En anna tanke ang din test är det att tiden du får baseras ju mkt på vilka resurser din dator utför samtidigt. Om du kollar mail varje minut, om en service kontrollerar lite statistiik, om OS:et skriver till HD:n etc... Jag skulle villja se 10 olika tidsresultat för de två testen du gjorde. Och sedan ta ut medeltiden.

//Johan N

Jag startade en ny tråd under "net framework" för fortsatt diskussion eftersom Mooosie redan löst tråden och vi befinner oss utanför den ursprungliga frågan.

Vi fortsätter på [Prestandaj&#228;mf&#246;relse mellan vbCrLf och Environment.NewLine].

/Mattias