CSharp vs. VB.Net Peformance by CLR.

Wizard.. how about writing an article to be posted on this site on best practices for coding (i.e. using shorts instead of doubles for for-next statements). I'd be very interested in reading something like that. -James

Same as many (most?) C++ programmer write poor C# or even managed C++!

Wizard is right about the many ways to optimize code for performance. If I had to guess, however, I'd say that C# lends itself to better performing IL simply because of the structure of the language. Again, this all boils down to good design. I'm in no way saying that a good VB programmer would write slower code than a sloppy C# programmer. As far as which language to pick, and why, I'm adamantly opposed to VB.Net on principle. Wizard said it right, this is a major shift. If you were a typical VB6 programmer, it may be an easier transition to VB.Net than to C#, but you will never be able to write quality code until you change your style and designs to take advantage of true object oriented languages and the benefits of the .Net framework. -James

The classic argument is to use the one which is closest to the language you are most familuar with (VB.NET for VB users, C# for C++ users). However I do not agree with this. The baisc design paradigms for making the best use of the .NET/CLR/Framework require a major shift from any of the old environments. People who migrate from a language tend to bring with them habits and techniques which may not be appropriate.

I agree, leaving the performance, do you see any good reasons for choosing VB.Net over C# or vice-versa.

There are probably thousands of differences which can make vb or c# generate faster code. There is no simple "cheat" sheet. This is why, when taken as a whole there is no performance related reason to choos one languge over the other. Remember that raw performance is almaost always a very minimal, insignificant issue compared to all of the other things you should be thinking about during a design. If you have a well though out and implemented design and then MEASURE a specific bottleneck that impact the program, you start to look at performance. Assuming this ever become important for one of your applications, then the ONLY way to evaluate the situation is through measurement and carefull analysis of the MSIL and native code.

Many Thanks for the efforts to clear the issue. Actually the whole thought in me arose after a discussion about Peformance issue between VB.Net and C#. Many were saying both wud be same. But to test things I had written a sample loop doing same things and expect to execute in same time. Are you aware of specific things that differ in execution between C# and VB.Net there by suggesting C# is better language to code? I didn't get your reason for not using double. can you elobrate?. Surprisingly when i changed to while loops VB.Net code executes faster?????

JamesDivine... I am under no such impression. My point is that *IF* the same MSIL code is generated then the performance is the same. The original poster asked about performance of the the *CLR* not of the code generator for VB vs the code generator for C#. The CLR does NOT care which language is used to invoke functions, if different languages generate different MSIL and calls into the CLR then the performance of the application will surely change. In the above example I could code the loop in C# shuch that it called the "CompilerServices.FlowControl::ForNextCheckR8" routine within the CLR [of courde this would be a strange and possibly stupid thing to do]. But IF I wrote the code that way the performance would be the same. Relating specifically to this sample, it is a good demonstration why it is not efficient to use "double" variables as the index of a for loop within VB. If you code the logic with a "while" loop in both cases you will se performance results that more closely align.

Running debug builds [easier to capture some of the things VB does for you behind the scenes] You will notice that VB makes an internal call WITHIN the for-loop to determine if the for loop has reached its termination value: call bool [Microsoft.VisualBasicMicrosoft.VisualBasic.CompilerServices.FlowControl::ForNextCheckR8] /// =========== /// VB CODE /// =========== For i = 0 To x 00000099 mov eax,dword ptr [ebp-30h] 0000009c mov dword ptr [ebp-40h],eax 0000009f mov eax,dword ptr [ebp-2Ch] 000000a2 mov dword ptr [ebp-3Ch],eax 000000a5 fldz 000000a7 fstp qword ptr [ebp-18h] 000000aa jmp 000000BD counter = counter + 1 000000ac fld1 000000ae fadd qword ptr [ebp-10h] 000000b1 fstp qword ptr [ebp-10h] Next 000000b4 nop 000000b5 fld1 000000b7 fadd qword ptr [ebp-18h] 000000ba fstp qword ptr [ebp-18h] 000000bd push dword ptr [ebp-14h] 000000c0 push dword ptr [ebp-18h] 000000c3 push dword ptr [ebp-3Ch] 000000c6 push dword ptr [ebp-40h] 000000c9 push 3FF00000h 000000ce push 0 // HERE IS THE GOTCHA 000000d0 call dword ptr ds:[007F6F1Ch] 000000d6 movzx esi,al 000000d9 test esi,esi 000000db jne 000000AC /// ============ /// C# CODE /// =========== for( i = 0 ; i<=x;i++) 0000008b fldz 0000008d fstp qword ptr [ebp-18h] 00000090 nop 00000091 jmp 000000A7 counter = counter + 1; 00000093 fld1 00000095 fadd qword ptr [ebp-20h] 00000098 fstp qword ptr [ebp-20h] for( i = 0 ; i<=x;i++) 0000009b fld qword ptr [ebp-18h] 0000009e fadd qword ptr ds:[078D0498h] 000000a4 fstp qword ptr [ebp-18h] 000000a7 fld qword ptr [ebp-18h] 000000aa fld qword ptr [ebp-28h] 000000ad fcomip st,st(1) 000000af fstp st(0) 000000b1 jp 000000B5 000000b3 jae 00000093

I think CPUWizard is going under the assumption that both VB.Net and C# compile into the EXACT same intermediate code, which I don't believe is the case. In theory, IL code compiled from VB.Net should be slightly less efficient than code compiled from C#. -James

Thanks, Herewith posting the same Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim ticks As Long = DateTime.Now.Ticks Dim i, counter As Double Dim x As Double counter = 0 x = TextBox1.Text For i = 0 To x counter = counter + 1 Next ticks = DateTime.Now.Ticks - ticks Dim ts As New TimeSpan(ticks) lbl1.Text = ts.TotalSeconds.ToString() End Sub private void button1_Click(object sender, System.EventArgs e) { long ticks = DateTime.Now.Ticks; double i, counter,x; counter =0; x = double.Parse(textBox1.Text); for( i = 0 ; i<=x;i++) { counter = counter + 1; } ticks = DateTime.Now.Ticks - ticks; TimeSpan ts = new TimeSpan (ticks); label1.Text = ts.TotalSeconds.ToString(); }

If you are executing the same code, then the execution time would be the same! Therefore you are executing different code! If you post exact examples of what you thing is the "same" code, then I can probably rxplain the difference.