C# 4.0

Вообще на ачатике как-то слабо освещалась тема нового .net, считаю что стоит создать какой-нибудь такой пост где все будут дрочить на новый .net

Наиболее понятно всё показано на схеме:


Хотел немного рассказать про использование DLR в C# 4.0 тут, был бы рад если вы тоже присоединились и отпостили что-нибудь интересное по теме.


Проще всего описать всё это дело примером:

Code:

   static void Main(string[] args)
        {
            Console.WriteLine("Привет вам из C# 4.0!");

            var a = "hello ";
            var b = 2323;

            dynamic c = a + b;

            Console.WriteLine("Результат: {0}", c); //"hello 2323"
            Console.ReadLine();
        }

Клёво, да? Кроме крутых вычислений это очень сильно упрощает жизнь, когда используешь позднее связывание, и все объекты и их типы мешаются в кучу и в итоге всё имеет тип object

 

И что клевого? Что все объекты мешаются в кучу?

Ага, и все в итоге тормозит безбожно.

 

Некому тут дрочить на нет 4

 

>>Ага, и все в итоге тормозит безбожно.
имеешь в виду boxing/unboxing?

 

Во-первых боксинг, во-вторых динамическая типизация.

Не поленился, и протестировал пример который дал топикстартер:

Code:

 DateTime now = DateTime.Now;

            for (int i = 0; i < 1000000; i++)
            {
                var a = "hello ";
                var b = 2323;

                dynamic c = a + b;
            }

            Console.WriteLine(DateTime.Now - now);

            now = DateTime.Now;

            for (int i = 0; i < 1000000; i++)
            {
                string a = "hello ";
                string b = "2323";

                string c = a + b;
            }

            Console.WriteLine(DateTime.Now - now);
            Console.ReadLine();

Резлультат выполнения:
00:00:00.4687500
00:00:00.0937500

То есть статическая типизация работает почти в 5 раз быстрее чем динамическая ...

 

Algol, а ты оптимизацию не забыл отрубить? а то 00:00:00.0937500 - как-то совсем нереально смотрится

 

Это без оптимизации.
И почему нереально? Одна десятая секунды это не так-то и мало.

 

для миллиона объединений строк - вообще не очень )
Вот то же на сях с плюсами и без:

Code:

#include "windows.h"
#include "string.h"
#include <string>
#include <iostream>
using namespace std;
#define st __int64 rrtr = GetTickCount();
#define et rrtr=GetTickCount()-rrtr; \
	/*if(rrtr>1){ __asm{int 3};*/ cout << rrtr <<endl;//}

int main(){
	{	
		st
		    for (int i = 0; i < 1000000; i++)
            {
                string a = "hello ";
                string b = "2323";

                string c = a + b;
            }
		et
	}
	{
		st
		    
            for (int i = 0; i < 1000000; i++)
            {
                char a[] = "hello ";
                char b[] = "2323";
                int l1 = strlen(a), l2 = strlen(b);
                char *c = (char *)malloc(l1+l2+1);
                strcpy(c,a);
                strcat(c,b);
                free(c);
			}
		et
	}
	int a;
	cin >> a;
	return 0;
}

вывод:
1407
1344

(на чистых сях такой код получился в результате постепенного улучшения)
с оптимизацией так (видимо, там таки что-то повырезано):
453
922

но чтобы на .NET было во столько раз быстрее..

 

Ну вот промежуточный код. Из него видно, что компилятор ничего не вырезает и чесно крутит цикл:

Code:

00000064  nop              
                string a = "hello ";
00000065  mov         eax,dword ptr ds:[022C3098h] 
0000006b  mov         dword ptr [ebp-4Ch],eax 
                string b = "2323";
0000006e  mov         eax,dword ptr ds:[022C309Ch] 
00000074  mov         dword ptr [ebp-50h],eax 

                string s = a + b;
00000077  mov         edx,dword ptr [ebp-50h] 
0000007a  mov         ecx,dword ptr [ebp-4Ch] 
0000007d  call        75CFC078 
00000082  mov         esi,eax 
00000084  mov         dword ptr [ebp-54h],esi 
            }
00000087  nop              
            for (int i = 0; i < 1000000; i++)
00000088  inc         dword ptr [ebp-48h] 
0000008b  cmp         dword ptr [ebp-48h],0F4240h 
00000092  setl        al   
00000095  movzx       eax,al 
00000098  mov         dword ptr [ebp-58h],eax 
0000009b  cmp         dword ptr [ebp-58h],0 
0000009f  jne         00000064 

 

Code:

                string a = "hello ";
00000065  mov         eax,dword ptr ds:[022C3098h] 
0000006b  mov         dword ptr [ebp-4Ch],eax 
                string b = "2323";
0000006e  mov         eax,dword ptr ds:[022C309Ch] 
00000074  mov         dword ptr [ebp-50h],eax 

^^ кхм если строки "выделяются" так, тогда может быть )

 

станет удобней писать различные паттерны проектирования

 

Я лишь беру пример ТС
На самом деле var это еще не динамическая типизация. Значение типа для var определяется на этапе компиляции. А вот dynamic - действительно динамическая типизация.
Мое мнение - dynamic введено просто для совместимости со скриптовыми языками типа питона.
Ну еще может оказаться полезным для COM, или всяких фокусов с reflection. В любом случае, польза от dynamic сомнительна, зато гемор в виде run-time exceptions - гарантирован.

 

Да, тоже не сторонник подобных нововведений. Как известно трамвай не давит людей на тротуарах независимо от того насколько пьян кондуктор (не помню кого цитирую). А из-за подобного сахара разработчик получает ещё одну возможность прострелить себе ногу.

 

>>А вот здесь я хочу отметить капитальный геморой C# при передаче измененных параметров между формами!

нет геморроя, если подход через *опу, то ответный результат будет в виде исп*ажнений.

var это не dynamic.

в 4.0 базовый функционал расширили.
сахар такая вещь, хочешь используй, хочешь нет. Дело вкуса и привычки, а как известно на вкус и цвет.

dynamic само по себе аналог variable (Delphi) имха.

чего я ждал в 4.0 это аналог оператора with вот этого мне не хватает.