я вообще большой любитель Васика но вот попробовал приведенные примеры (правда там ошибка)

c# 0.04 сек

vb.net 3.1 сек

Вот гады, они наверное что-то специально сделали что бы медленее работало

А теперь вопрос в каких еще случаях это критично или же во всех c# настолько быстрее

можно ли расчеты писать на c# ?

Ответить

Я проверил - действительно C# намного быстрее. (
Кстати, а как вы измеряли скорость ?

Попробовал дизассемблировать (ildasm.exe).
Конкретно этот цикл:

Для VB.Net:

  IL_001f:  ldc.i4.0
  IL_0020:  stloc.0
  IL_0021:  ldloc.0
  IL_0022:  conv.r8
  IL_0023:  call       float64 [mscorlib]System.Math::Sin(float64)
  IL_0028:  ldloc.0
  IL_0029:  conv.r8
  IL_002a:  call       float64 [mscorlib]System.Math::Cos(float64)
  IL_002f:  div
  IL_0030:  stloc.1
  IL_0031:  ldloc.0
  IL_0032:  ldc.i4.1
  IL_0033:  add.ovf
  IL_0034:  stloc.0
  IL_0035:  ldloc.0
  IL_0036:  ldc.i4     0x989680
  IL_003b:  ble.s      IL_0021

Для VC#:

  IL_001e:  ldc.i4.0
  IL_001f:  stloc.0
  IL_0020:  br.s       IL_0036
  IL_0022:  ldloc.0
  IL_0023:  conv.r8
  IL_0024:  call       float64 [mscorlib]System.Math::Sin(float64)
  IL_0029:  ldloc.0
  IL_002a:  conv.r8
  IL_002b:  call       float64 [mscorlib]System.Math::Cos(float64)
  IL_0030:  div
  IL_0031:  pop
  IL_0032:  ldloc.0
  IL_0033:  ldc.i4.1
  IL_0034:  add.ovf
  IL_0035:  stloc.0
  IL_0036:  ldloc.0
  IL_0037:  ldc.i4     0x989680
  IL_003c:  blt.s      IL_0022

Очевидно, VC# использует pop вместо stloc.1 и т.д., но я хотя и вижу разницу, но не могу пока понять, почему один быстрее. Может кто-нибудь обьяснить ?

Ответить

long startTime = DateTime.Now.Ticks;

тут цикл

long endTime = DateTime.Now.Ticks;

TimeSpan timeTaken1 = new TimeSpan(endTime - startTime);

Ответить

Да, я тоже почти так мерял.

Кстати, у VC# есть в свойствах проекта - Optimize Code. Если отключить, скорость его и VB становится равной. В VB тоже есть Enable optimizations, но разницы при нём включенном и выключенном я не заметил.

Может, баг Microsoft ? Тем более что параметры компиляторов VB и VC# для обоих этих свойств "/optimize". Хотя и для разных компиляторов, но ведь не зря всё делали схожим.

Ответить

У меня на всяких сложных штуках разрыв немного сократился но все равно есть.

Помоему этот г... действительно не делает оптимизацию

Ответить

 Я идиот ! Понял ! Вот в чём оптимизация VC# ! Мы после этого цикла ни разу не запрашиваем значение k, поэтому он просто ему ничего и не присваевает ! Он просто удаляет полученное при делении значение из стека в никуда ! А VB присваивает в любом случае.

Проверил - теперь почти одинаково !

Ответить

Я сделал клас в котором хранится рад данных целых, даллов порядка, строка 15

потом с помощью датаридер АДО.Нет все считываю.

Код на ВБ и С# индентичен вплоть до строчек

Но считвание данных 70000 объектов из бд

vb = 3.8 c

c#=3.2 c

еще у меня сложилось мнение что из обычных длл функции и процедуры вызываются в разы медленнее чем встроенные функции, да помоему в с#  из длл быстрее вызывает

Ответить

2Darxeth

Я бы согласился, по поводу помещения в стек, но нашел еще другие отличия в производительности. Вот код:

VB
        Dim i As Int32 = 0, j As Int32 = 3, k As Int32 = 343, m As Int32 = 0, l As Int32, tmp As Int32
        Dim si As Single = 0.0F, sj As Single = 3.0F, sk As Single = 3453.0F, sm As Single = 0, stmp As Single
        Dim tm As Single = System.DateTime.Now.Millisecond, ta As Single
        For l = 0 To 100000000
            ' Sample #1
            'If i = 1 And j = 3 Then k = k + 1
            ' Sample #2
            'm = j * i * k
            'sm = sj * si * sk
        Next
        ta = System.DateTime.Now.Millisecond - tm
        MsgBox(ta)
        l = k / 2
        tmp = m
        stmp = sm
C#
 Int32 i=0,j=3,k=343,m=0,l,tmp;
 Single si=0F,sj=3F,sk=3453F,sm=0,stmp;
 Single tm=System.DateTime.Now.Millisecond,ta;
 for(l=0;l<=100000000;l++)
 {
//  Sample #1
//  if(i==1 && j==3)
//   k++;
//  Sample #2
//  m=j*i*k;
//  sm=sj*si*sk;
 }
 ta=System.DateTime.Now.Millisecond-tm;
 MessageBox.Show(ta.ToString());
 l=k/2;
 tmp=m;
 stmp=sm;

как вы поняли пример №1 показывает, что VB, как и раньше, не оптимизирует обработку операторов ветвления, а второй, что математика тоже не оптимизируется (пр. X=0*Y) в отличии от C#. Хотя это всего лишь предположения, ответ может дать только асм, а я за него еще не брался.

Ответить

Не знаю. Первый пример показывает у меня одинаковый результат. Ты не забыл поставить в VB-опциях Remove Integer Overflow Checks ?
В VC# оно стоит по умолчанию.

Что касается ветвления - C#'чному && эквивалентно не And, а AndAlso.

Второй пример посмотрел в asm (то есть в MSIL) - абсолютно идентичен.
Сейчас меня и скорость идентична. Проверь Remove Integer Overflow Checks.

Кстати, интересно, что MSIL всё считает в стеке.
Если asm делает

add value1 value2

то MSIL фактически

push value1
push value2
add

Забавно.

Ответить

Remove Integer Overflow Checks поставлен, но код идентичный вплоть до строчки - заполнение из бд в массив классов работает медлее на 0.6 с вообще не понятно почему

А вопрос почему настолько медленее вызываются фукции из обычных длл мне вообще не понятен. В c# помоему быстрее

Я в vb даже полную проверку данных включил.

Ответить