C# vs C – Big performance difference

by

You must be comparing debug builds. I just compiled your C code, and got 

Time elapsed: 0.000000

If you don’t enable optimizations, any benchmarking you do is completely worthless. (And if you do enable optimizations, the loop gets optimized away. So your benchmarking code is flawed too. You need to force it to run the loop, usually by summing up the result or similar, and printing it out at the end)

It seems that what you’re measuring is basically “which compiler inserts the most debugging overhead”. And turns out the answer is C. But that doesn’t tell us which program is fastest. Because when you want speed, you enable optimizations.

By the way, you’ll save yourself a lot of headaches in the long run if you abandon any notion of languages being “faster” than each others. C# no more has a speed than English does.

There are certain things in the C language that would be efficient even in a naive non-optimizing compiler, and there are others that relies heavily on a compiler to optimize everything away. And of course, the same goes for C# or any other language.

The execution speed is determined by:

  • the platform you’re running on (OS, hardware, other software running on the system)
  • the compiler
  • your source code

A good C# compiler will yield efficient code. A bad C compiler will generate slow code. What about a C compiler which generated C# code, which you could then run through a C# compiler? How fast would that run? Languages don’t have a speed. Your code does.

More Related Contents:

  1. Where is likely the performance bug here? [closed]
  2. Best way to reverse a string
  3. String vs. StringBuilder
  4. How slow are .NET exceptions?
  5. Implementing a log viewer with WPF
  6. How to get object size in memory? [duplicate]
  7. Does C# optimize the concatenation of string literals?
  8. Debug vs. Release performance
  9. LINQ: Not Any vs All Don’t
  10. Why does the Contains() operator degrade Entity Framework’s performance so dramatically?
  11. String interning in .Net Framework – What are the benefits and when to use interning
  12. Using lambda expressions for event handlers
  13. Why is LINQ .Where(predicate).First() faster than .First(predicate)?
  14. String Interpolation vs String.Format
  15. How does extern work in C#?
  16. How performant is StackFrame?
  17. How to force a number to be in a range in C#? [duplicate]
  18. Is String.Format as efficient as StringBuilder
  19. Why is this F# code so slow?
  20. async await performance?
  21. Warm-up when calling methods in C#
  22. How slow is Reflection
  23. Why is this faster on 64 bit than 32 bit?
  24. When to change the Generate Serialization Assembly value?
  25. Setting properties via object initialization or not : Any difference ?
  26. Slow SoapHttpClientProtocol constructor
  27. Winforms: SuspendLayout/ResumeLayout is not enough?
  28. Heap versus Stack allocation implications (.NET)
  29. Why subsequent direct method call is much faster than the first call?
  30. C# Dynamic Keyword — Run-time penalty?

Leave a Comment