C# 3.0 Orcas 简介

Posted on 2005-09-20 11:42 idior 阅读(9428) 评论(108) 编辑收藏

Implicitly typed local variables

   15     var i = 5;
   16     var s = "Hello";
   17     var d = 1.0;
   18     var numbers = new int[] {1, 2, 3};
   19     var orders = new Dictionary<int,Order>();

局部变量的声明变得非常方便, 编译器会根据上下文自动推导出变量的类型.这个功能在3.0中被广泛使用.

下面的代码更加方便:

   15     var sum = 0;
   16     var intArray = new [] { 1,2,3,4};  //used to be  new int[](1,2,3,4)
   17     foreach ( var i in intArray )
   18     {
   19         sum += i;
   20     }

在匿名类型的支持下,你甚至可以这样玩.

   15     var contacts = new[]
   16     {
   17         new {
   18             Name = "idior",
   19             Website= new[] { "idior.cnblogs.com", "www.alphatom.com" }
   20             },
   21 
   22         new {
   23             Name = "dudu",
   24             PhoneNumbers = new[] { "www.aopdotnet.com" }
   25             }
   26     };

可见3.0下的代码是多么的简洁.
需要注意的是这里的var和javascript中可不一样. 它是强类型的, 也就是说var sum=0;其中的sum的类型仍然是int.
只不过这个推导过程由编译器做了, 如果你查看反编译的源代码你会发现var sum=0; 变成了int sum=0;
之所以要引入var, 更多的由于Linq中查询结果的需要. 因为对于复杂的查询语句, 你很难判断出返回的结果类型,甚至有时返回的是匿名类型,这个时候var就会大大减轻程序员的负担.

Extension methods

在2.0的集合一文中, 我对新List<T>加入的Foreach方法大加赞扬了一番, 同时也指出其不足, 并提供了一个扩展方法. 现在有了Extension Method的支持,要想对原有类扩展扩展功能简直太方便了.

比如我想为所有的集合类加入Foreach的方法.

   24     class Static Algorithm 
   25     { 
   26         public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action) 
   27         { 
   28             foreach (T obj in collection) 
   29             { 
   30                 action(obj); 
   31             }            
   32         } 
   33 
   34         public static void ForSpecification<T>(this IEnumerable<T> collection, Action<T> action, Predicate<T> filter) 
   35         { 
   36             foreach (T obj in collection) 
   37             { 
   38                 if (filter(obj)) 
   39                     action(obj); 
   40             }            
   41         } 
   42     } 

来看看如何使用:

   15     var numbers = new [] {"hello", "world", "Linq"};
   16 
   17     numbers.ForEach (delegate(string str)   // equal to Algorithm.ForEach(numbers,...)
   18                      { 
   19                         Console.WriteLine(str); 
   20                      } 
   21                     );  

Extension methods名副其实, 确实为功能扩展带来了极大的方便.
如果你接触过AOP的话,你会发现它和AOP中的静态横切(Mixin)的作用很象. Extension methods是否真的将扩展的方法加入原来的类型当中, 就像多继承那样? 答案是否定的, 这里仅仅是一个语法糖,编译器会自动将numbers.ForEach(...) 变回到Algorithm.ForEach(numbers,...).

Lambda Expressions

如果说你现在还没有习惯使用匿名方法, 没关系,一年后你也会不自觉的使用到它, 而Lambda Expressions则是对匿名方法的进一步增强, 两年后你就会使用它来代替匿名方法.

如果你看了我在CollectionClosureMethod in .Net 一文中利用匿名方法对Martin Fowler的CollectionClosureMethod in Ruby的模拟, 但是觉得很丑陋的话, 那么请你看看下面的代码:

   15     managers = employees.select {|e| e.manager?} //ruby 
   16 
   17     List<Employee> managers = employees.FindAll(delegate(Employee e)                                              
   18                                                 {
   19                                                     return e.IsManager == true;
   20                                                 });      //C# 2.0
   21 
   22     var managers = employees.Select(e => e.IsManager==true);   //C# 3.0

   21     offices = employees.collect {|e| e.office}   //ruby 
   22 
   23     List<Office> offices = employees.ConvertAll<Office>(delegate(Employee e)                                                                                            
   24                                                        {
   25                                                            return e.Office;
   26                                                        });      //C# 2.0
   27 
   28     var offices = employees.Select(e => e.Office);    //C# 3.0

有关Lambda表达式的更多内容请见这里.

Object and Collection initializers

对象的初始化的代码将变得异常简洁.

   15     var idior = new Person{Name = "ning", Surname = "xu"};
   16 
   17     var persons = new List<Person> 
   18     { 
   19         new Person{Name = "ning", Surname = "xu"}, 
   20         new Person{Name = "Foo", Surname = "Bar"}
   21     } 

Anonymous types

   15     var idior = new 
   16     {
   17         Name = "idior", WebSite = http://idior.cnblogs.com/};
   18         Console.WriteLine(idior.WebSite); 
   19     }

Query Expressions

将关系型查询语句引入面向对象的世界, 大大增强了语法安全性, 很久以前我也对此有过介绍.

   15     from c in customers
   16     where c.City == "London"
   17     select c

相应的Lambda表达式描述

   15     customers.Where(c => c.City == "London")

该语法的表达能力非常强, 对where , select , group , orderby , into 的语法都有支持.

结合前面的Anonymous types. 还可以方便的获得多个查询结果,并包装成类

   15     var payingCustomers =   from c in db.Customers 
   16                             where c.Orders.Count > 0 
   17                             select new { Email = c.Email, Name = c.Name };
   18     foreach (var c in payingCustomers)
   19     {
   20         SendDiscountOffer(c.Email, c.Name);
   21     }

这个功能将彻底改变持久层的操作.

以上仅仅是对Linq 的初步认识, 变化之大远远超出2.0较之于1.0. 看了之后实在心痒痒的, Linq在动态语言和Function Programming方面的能力大大增强. 再对比一下java那边, 似乎还没听到6.0的什么消息, 不知道他们将如何应对.net的下一波冲击!

以上的介绍将各个新增功能分开逐一介绍, 表面看了好像仅仅是增强了一些新的语法, 增加了C#语言的灵活性, 甚至会有人认为此举得不偿失, 但是最重要的概念不是在于这些小的语言点,而是通过它们的合作而产生的LINQ. 将类似关系型(实际还是面向对象的)的语言引入到C#中,大大增强了C#对于数据的操作能力(内存数据---集合, 外部数据--DataBase,XML ).

Linq何时才能用? 虽然在语法层面Linq加入了很多新的内容, 但是在做完上面的范例之后, 你会发现Linq中并没有在CLR底层加入什么新的元素. 所有新的功能仍然是建立在泛型的基础上,然后由编译器完成大部分的代码转化和生成. 以上的程序集在reflector中都是可以被反编译的,并没有什么新的底层元素不可被识别. 因此,个人估计只要MS不断推出Linq新的测试版本, 我想Linq并不需要等到Orcas才能发布.或许在.Net 2.1时就可以正式发布了. Orcas应该不止是Linq这么简单, 它应该会在底层加入新的元素, 这样才叫主版本的变化嘛,就像2.0加入了泛型.

推而广之, 如果你想为.Net增强新的功能,比如加入AOP的功能, 那么你也可以考虑实现自己的一套增强型编译器. 不过C++好像就是这样被毁掉的. 真怕以后出现n多版本的C#.

Orcas的相关资源

#1楼  回复 引用

2005-09-14 20:55 by 灵感之源

codeproject今天也有类似的文章

#2楼 [楼主] 回复 引用 查看

2005-09-14 20:59 by idior

因为PDC开始了嘛. 国内的普及就靠博客园啦, 总不能一直落后老外吧. VB9就等装配脑袋的吧 :p
什么时候中国能办PDC喔!!!

#3楼  回复 引用

2005-09-14 21:09 by 毒姑求BUY[未注册用户]

新的语法看不到好处，但却能预见有不少坏处，情况与PHP5的改革一样，不见其利，先见其害。

#4楼  回复 引用 查看

2005-09-14 21:11 by Teddy's Knowledge Base

感觉都有点像js呢~~

#5楼 [楼主] 回复 引用 查看

2005-09-14 21:11 by idior

对于不懂动态语言和Function Programming的人来说确实看不到什么好处, 当然更大的权利意味着更大的责任. 至于利弊至少得等一阵子才能看出来. 但是动态语言和Function Programming的增强的确是大势所趋.

#6楼  回复 引用

2005-09-14 22:05 by CsOver[未注册用户]

idior的速度真快..

#7楼  回复 引用 查看

2005-09-14 22:06 by yuxs

这是不是改的有点太大啦，真是一时适应不了！
不过看起来还真是很方便！

#8楼  回复 引用

2005-09-14 22:14 by Web Hosting Review[未注册用户]

更新换代真快哦。

#9楼 [楼主] 回复 引用 查看

2005-09-14 22:24 by idior

@yuxs
以上功能全是增强,不是改变.
你原有的方法依然有效,不过没这样方便.

#10楼  回复 引用 查看

2005-09-14 22:57 by Cavingdeep

我预计C# 3.0将是一个失败的产品，有得亦有失，它不是Python，当它像Python靠拢时它将失去所有已经得到的用户！这点我就觉得Java社区做的比较好，Java是否应该进化、怎样进化不是Sun一家说的算的，我们不能总被别人牵着鼻子走，逼着我们“升级”。

个人并不觉得这些特性会大幅度提高开发效率，反而会导致不良反应。

#11楼  回复 引用

2005-09-14 22:58 by rr[未注册用户]

怎么感觉在往vb上靠啊？

#12楼  回复 引用

2005-09-14 23:23 by redmoon

我也正想一个介绍C#3和LINQ的文章呢，结果被你捷足先登了。
确实C#3加入了许多动态特性和Function Programming，这是趋势。但是没有什么失败的啊。反而我觉得IronPython 就有点鸡肋了。

#13楼  回复 引用

2005-09-14 23:54 by gozh2002

LINQ sounds more excited and who can introduce the difference between
C omega and linq.

and I think C#3.0 should have a sub-set scripting language (with C# grammar like) rather than do it in this way...

If there is no demarcation line between static type and dynamic type
we may just program with ruby now then...

#14楼  回复 引用

2005-09-15 08:45 by 振河

和VB上的变体类型差不多

#15楼 [楼主] 回复 引用 查看

2005-09-15 08:48 by idior

@redmoon
由于时间原因,这篇文章写的过于简单了, 你完全可以再详细介绍一下.
动态特性和Function Programming这是当前语言发展的趋势, ms加入这些特性也很吸引人, 个人还是比较看好的. 何况是Anders这样的牛人设计的.

#16楼  回复 引用

2005-09-15 08:48 by huobazi[未注册用户]

怎么象弱类型的了

#17楼  回复 引用

2005-09-15 08:55 by HD

C#，你什么时候变成这样了！如上面一位朋友所说，感觉自己在写JS。
－－－－－－－－－－
这语言方面的更改，在每个版本里都有很多的不同。很昏死！

希望的是功能的增强，而不是语言的大变造。VB和VB.net就是一个很典型的例子，已经体无完肤了！

#18楼  回复 引用 查看

2005-09-15 09:00 by Ninputer

这还叫动态，这全部都是编译时静态特性！本来C#还希望加入动态tuple还有后期绑定之类的，现在看来都砍掉了。想用请关注VB9
不创新就等于死亡。不知道为什么有人会否定这些新特性，我看到第一反应就是：C#有前途。这些东西并不像有些人想得那么不清晰或者有隐患，深入了解一下吧，很多人的思想都落后了。
我会在这里详细介绍XLinq，至于DLinq，有兴趣的高人自会介绍。

#19楼 [楼主] 回复 引用 查看

2005-09-15 09:15 by idior

@Ninputer
毕竟至少是两年后的技术, 很多人1.0还没用熟,让他看了这个当然头疼. 所以要加大宣传啊. 我看你的介绍好像VB9和C#差别不是太大嘛.

#20楼  回复 引用

2005-09-15 09:17 by [ IceSharK - PP.Poet ]

@Ninputer

“不创新就等于死亡。不知道为什么有人会否定这些新特性”

呵呵别急哦社会接受新东西是需要时间的么

技术狂飙性和基础扎实性社会通常会选择后者

一个系统不会用到所有特性

一个系统也不会非要=某个特性出来才能做

计算机科学和计算机工业是有点点不同的

p.s

看了你写的VB9的相关介绍又唤起我的美好回忆了

n年前

10 ? Hello
20 GOTO 10

呵呵

#21楼  回复 引用

2005-09-15 09:22 by lovebanyi[未注册用户]

是C# 吗? 哪我2.0也不用学了..看过去就是js啊

#22楼  回复 引用

2005-09-15 09:25 by lovebanyi[未注册用户]

js 方便但是判断相等的时候就郁闷了. 你不清楚它到底是int 型还是string 类型

#23楼  回复 引用 查看

2005-09-15 09:27 by Ninputer

@idior，VB9在XML方面有独到之处，你可不要小看XML字面量哦

Dim CountriesWithCapital As XElement = _
<Countries>
    <%= Select <Country Name=(Country.Name)
                        Density=(Country.Population/Country.Area)>
                 <Capital>
                   <Name><%= City.Name %></Name>
                   <Longitude><%= City.Longitude %></Longtitude>
                   <Latitude><%= City.Latitude %></Latitude>
                 </Capital>
               </Country> _
        From Country In Countries, City In Capitals _
        Where Country.Name = City.Country %>
</Countries>

#24楼  回复 引用

2005-09-15 10:03 by js才怪[未注册用户]

拜托各位不要看到var, 就象看到亲人似的, Implicitly typed local variables只是最基本的功能, 什么叫lamda表达式你知道了吗?什么叫查询表达式你知道了吗?

#25楼  回复 引用

2005-09-15 11:19 by [ IceSharK - PP.Poet ]

呵呵楼上的经典

“拜托各位不要看到var, 就象看到亲人似的”

#26楼  回复 引用 查看

2005-09-15 12:55 by 老翅寒暑

C#语言风格不宜漂移过大，否则对它的发展不利

#27楼  回复 引用

2005-09-15 13:39 by vervethe[未注册用户]

改进很多，类型还是强类型的，只是外表像弱类型而已。
不过比起Ruby语言，还是很罗嗦。
还是ruby语言最省。

#28楼  回复 引用

2005-09-15 14:12 by 路过[未注册用户]

动态是趋势，fp可是陈货了，况且曾被嗤之以鼻的，如何也成了趋势？之于c#3也就是个附带品罢了

#29楼 [楼主] 回复 引用 查看

2005-09-15 14:43 by idior

成货在一定的时候也会流行啊, ajax不就是一个现成的例子.

#30楼  回复 引用

2005-09-15 15:06 by 路过[未注册用户]

fp和oo侧重的方面有着本质的不同，fp思想注重函数的求值过程，oo则侧重模式的搭建。fp一度被认为在只能用于理论和数学等方面的研究，之于商业软件领域无用武之地

虽然，fp和oo并无矛盾之处，一个语言同时支持是完全可行的，但同时使用两种思想搭建一个软件的框架却是矛盾的，换句话说，c#即使支持了fp方式，在正规的项目中，fp也将仅仅能用在一些“小”处，不能认为使用了lambda就是用上了fp

偶脚得，oo远比fp更适合商业应用框架的搭建这是不争的事实，由此可知，在这个领域，fp是流行不起来的，呵呵

故此发表了偏颇之言，还望指正

#31楼  回复 引用 查看

2005-09-15 15:44 by linkcd

Function Programming, 赞
严重期待CSharp 3.0!

以后在.net也有得玩咯~~ 不过要赶快看完sicp

#32楼 [楼主] 回复 引用 查看

2005-09-15 15:47 by idior

现在的趋势就是将FP就是用在小处，提高编写代码的效率。
FP写出来的代码很简洁。

#33楼  回复 引用

2005-09-15 17:06 by zz[未注册用户]

我要用C#3。0开发游戏与多媒体，还有3D与硬件驱动能不能作呢？好看中用不呢？
MS好象在作时装发布会！！

#34楼  回复 引用

2005-09-15 17:10 by ZZ[未注册用户]

随便问一下，C++9.0怎么样呢？

#35楼  回复 引用

2005-09-15 19:08 by gnuer[未注册用户]

C# 3.0 specification 中文版本
http://www.linuxsir.org/bbs/showthread.php?p=1265267#post1265267

#36楼  回复 引用

2005-09-15 21:33 by gozh2002

我觉得FP会流行的一点是，FP上应该比较容易写并行的程序。
还有LINQ也会很有用是因为可以方便的把数据调入内存，
进行并行查询来增加效率。
很多学术上的理念以前不好用，不过硬件的发展方向使得这样
想法会越来越有应用前景。

#37楼  回复 引用

2005-09-16 09:21 by Ivony...[未注册用户]

如果那个写的程序里面充斥着var，我将拒绝阅读。

C#是强类型的，

var i = 10000000000000000000;

谁能告诉我i是什么类型的？
int,long？都不对。

不是ulong就是decimal。

拜托，这种程序叫人怎么读！！！

还有其他的特性，并不是不好，但是语法太乱，关键字太多了。

C进化到C++，改动那么大，也不过增加了数个关键字而已，C#关键字本来就够多的了，还弄出什么from、where出来，还叫人怎么写？

#38楼  回复 引用 查看

2005-09-16 09:30 by mikespook

不管你是什么语言最终都是表达的“顺序”“循环”“条件”这三个祖师。关键字的作用其实只是为了简化代码，使得代码看起来更清晰，容易阅读。比如foreach和用while编写的功能等同的语句。

汇编之所以让许多人感觉暴难，就是因为同样的功能，可以使用的编写方法却有许多种。

如果引入了太多的关键字，而数个关键字其实都可以表达同样的功能语句，那么不但不会降低复杂度，反而会由于个人编写习惯的不同造成代码更加难以阅读。

#39楼  回复 引用

2005-09-16 09:32 by 刘典[未注册用户]

我觉得不能孤立的说动态语言好还是不好，他们都有自己的应用范围，强类型语言适合编写通用模块，这种模块特点是复杂，通用性强。对于复杂的代码如果用动态语言对开发效率和运行效率都有影响。因为对于复杂系统如果不能自动做类型检查的话会产生很多不容易调试的bug。对运行来说几乎所有操作都要检查类型，这个开销是很大的。动态语言更适合做大粒度模块之间的粘合。这个级别上的特点是运行时间短，因为大多数运行时间都集中在模块里，代码简单，因为只是起到粘合作用，容易发生变更，对于所有需求变更几乎都是集中到这个层次上。这样就发挥了动态语言的灵活的特点。
以上用稍微学术点的话来说就是“用强类型语言构建原语，用动态语言对原语进行组合产生复杂的应用”

顺便说一下 lambda可不只是简单的匿名函数那么简单。他涉及到很多复杂的数学概念。而且.net的匿名delegate根本算不上lambda。

#40楼  回复 引用

2005-09-16 09:38 by 刘典[未注册用户]

刚才没仔细看，以为c#变成动态语言了。原来是会根据上下文自动推导，这种东西在ml语言里早就有了。但是对于c#来说看不出任何好处。

#41楼  回复 引用

2005-09-16 10:02 by [ IceSharK - PP.Poet ]

@Ivony...

var 不是这样用的吧

大家去看看这个吧

http://www.microsoft.com/downloads/details.aspx?FamilyID=b056a273-69f8-4871-b95d-4ebd2806f62f&displaylang=en

#42楼 [楼主] 回复 引用 查看

2005-09-16 10:34 by idior

var是强类型的，是类型安全的。var主要与其它特性结合运用起来会非常方便，比如结合查询表达式，匿名类使用。
orcas也绝不是什么js. 希望大家了解以后再来谈，不要那么浮躁。

---
而且.net的匿名delegate根本算不上lambda。
---
没有匿名delegate这种说法。lambda表达式确实有很多的数学背景，但是从编程语言来说的是针对lisp中的lambda表达式的概念。

---
原来是会根据上下文自动推导，这种东西在ml语言里早就有了。但是对于c#来说看不出任何好处。
---
其实如果你什么都想自己推导自己做的话，也没必要学计算机了。

#43楼  回复 引用 查看

2005-09-16 11:38 by Ninputer

说到匿名方法，其实它的closure是使其接近FP思想的一个关键点，如果没有closure，匿名方法就成了语法糖。同样VB9中的Nested Function也正是突出其Closure的特点。FP其实是一种很古老的编程范式，做事就和图灵机一样的过程。FP讲究组合，整个程序就是一个创建函数和组合函数的过程，就像用一堆积木将程序堆积出来。这种思想和OOP确实是完全不同的，但不可否认在语言中少许掺入一些FP的思想会给编写代码带来很大方便，因为有时候FP的表达方法更接近人想问题的思路。

其实说起Lambda表达式，其实是计算机科学里一个很有趣的东西，比如用C# 3.0的语法为例，可以用Lambda表达式实现Church整数

Func<Func<T, T>, Func<T, T>> _0 = f => x => x;
Func<Func<T, T>, Func<T, T>> _1 = f => x => f(x);
Func<Func<T, T>, Func<T, T>> _2 = f => x => f(f(x));

可以定义一个后继元函数求Church整数n的后继元n + 1

Func<Func<Func<T, T>, Func<T, T>>, Func<Func<T, T>, Func<T, T>>> SUCC
　　= n => f => x = > f (n(f)(x));

这样SUCC(_1)就等于_2，还可以定义加法，乘法，前驱元n - 1，逻辑元算等等

#44楼  回复 引用 查看

2005-09-16 11:42 by Ninputer

上文假设Func<T, T>是

public delegate R Func<A, R>(A obj);

#45楼  回复 引用

2005-09-16 12:51 by [ IceSharK - PP.Poet ]

@idior

道不同不相为谋

不和他们说了

没意思

#46楼  回复 引用 查看

2005-09-16 13:03 by 维生素C.NET(范维肖)

我在介绍Nermele语言的时候就提过Function Programming,在研究C# 3.0前可以通过Nemerle来步入这种方式的殿堂

#47楼  回复 引用 查看

2005-09-16 14:12 by Ninputer

C# 3.0引入Lambda不是为了做FP的，基本上就是为了查询

#48楼  回复 引用

2005-09-16 14:17 by 刘典[未注册用户]

"没有匿名delegate这种说法。lambda表达式确实有很多的数学背景，但是从编程语言来说的是针对lisp中的lambda表达式的概念。"

晕倒，真不知道你知道不知道什么是lambda。恐怕你也仅仅知道lisp里有lambda这么个概念吧。什么是lambda你根本说不出来。C#连内部类的对象自动携带所处对象的能力都没有还敢叫嚣支持lambda。就象 Ninputer说的那样不过是给deleagte加个语法糖衣。

ms总是把自己的垃圾和一些高深的概念联系到一起，让用他那弱智工具的人以为自己真的是个高手。本来就是他的商业策略，没想大真有那么多人上当。

to [ IceSharK - PP.Poet ] ：你连我的话都听不明白不配谈“道”

#49楼  回复 引用 查看

2005-09-16 14:27 by Ninputer

@刘典

你说的“内部类的对象自动携带所处对象的能力”就是Closure，C#的匿名方法当然支持。不会我们可以学，我到时候会转载一些关于Lambda演算和FP其他概念的文章供大家学习，嘲讽和贬低是无法传播知识的。

#50楼  回复 引用

2005-09-16 14:48 by 刘典[未注册用户]

不好意思，我语言是有点过激了。表示道歉：）
我开始不过是表达自己的观点，也希望和大家交流知识，写了那么多没功劳也有苦劳啊。却被idior断章取义的胡乱批判。
C#的匿名方法支持Closure我还真不知道。C#的局部变量都是在堆栈里的怎么作到Closure啊？我想最多也就是做到类似java内部类那种仅仅携带对象上下文而已，做不到携带所有上下文信息。

#51楼 [楼主] 回复 引用 查看

2005-09-16 15:54 by idior

我在CollectionClosureMethod in .Net 中已经提到了Closure在.net下的用法，而且关于closure和匿名方法的区别在国外也有讨论。

lambda表达式我以前也没有去深入了解过，毕竟我不是搞数学的，对计算理论研究兴趣也不大。而且ms也在自己的文档中也表示lambda表达式仅仅是匿名方法的增强，没有像你说的胡吹乱吹。个人认为ms引入lambda表达式的主要目的就是在LINQ中加以运用。它的目的不是变成Fortran，Lisp。方便的创建方法和数据就是lambda表达式在.net中的目的，当然如果你愿意介绍有关lambda的详细内容，我也很高兴学习一下。

Orcas带来的变化总比没有变化好，即使这些思想有问题，如果不去了解你有怎么知道问题在哪，通过ms的问题来学习更是一个好的机会。

BTW 我在这里介绍orcas仅仅是让大家了解一下新的思想新的趋势，为什么很多人总要这么浮躁非要妄加批评呢，看到var就说是js, 看到lambda表达式就不顺眼，在.net的社区尚且如此，要是在其它社区岂不被骂死. 有新的好东西去学习总是好的嘛，就像有这篇文章总比没有好一样。

#52楼  回复 引用

2005-09-16 17:33 by [ IceSharK - PP.Poet ]

@idior

“BTW 我在这里介绍orcas仅仅是让大家了解一下新的思想新的趋势，为什么很多人总要这么浮躁非要妄加批评呢，看到var就说是js, 看到lambda表达式就不顺眼，在.net的社区尚且如此，要是在其它社区岂不被骂死. 有新的好东西去学习总是好的嘛，就像有这篇文章总比没有好一样。”

诚恳！

说的好！

-------------------------------------------------------

@刘典

"你连我的话都听不明白不配谈“道” "

？

你是谁呀？我们认识吗？

你说什么了？

我没听你说呀

也没有给你说呀

你怎么了？

疯了？要打疫苗不？

我瘦屁股上大腿上肉不多你换别人咬吧

#53楼  回复 引用

2005-09-17 12:53 by castl[未注册用户]

@[ IceSharK - PP.Poet ]
呵呵，技术争论没必要那么激动。

#54楼  回复 引用

2005-09-17 15:59 by 刘典[未注册用户]

@[ IceSharK - PP.Poet ]

你自己去看看我最开始的发言。带一点人身攻击的性质了么？有一点不负责任的评论么？我不过是在阐述我自己关于动态语言和强类型语言的观点，评论根本没有带任何感情的倾向性，因为大家在说动态语言，我说了一点自己看法而已。后来我发现var并不是动态类型，只是让编译器自动推导类型，我也补充说明了。
最后说“lambda可不只是简单的匿名函数那么简单。他涉及到很多复杂的数学概念。而且.net的匿名delegate根本算不上lambda。”也是经过我自己代码检验才得到的结论，不信你可以试试下面代码能不能通过编译（.Net Framework 2.0 beta1）：
public class C {
delegate void D(int p);
D f(out int o) {
return delegate(int p){ o = p; };
}
public static void Main(string[] argv) {
int a;
D d = new C().f(out a);
d(10);
System.Console.WriteLine(a);
}
}
而真正支持lambda的语言比如ruby同样功能的代码就可以正常运行(ruby 1.8.2)：
class V
attr_reader :var
attr_writer :var
end

def f(v)
proc do |p|
v.var = p
end
end

v = V.new
f(v).call(10)
puts v.var

在加上C#的局部变量是在stack里的，这就导致他不可能实现lambda演算中所必须的Closure。所以我得出“c#2.0的所谓的lambda根本算不上真正的lambda”的结论，难道这有错么？

然后idior却对我的言论断章取义的胡乱指责，因此我说了一些过激的话，并且也做了道歉，我说话有理有据，你却说一堆抬杠的话还说我疯了，真不知道到底是谁疯了？

#55楼 [楼主] 回复 引用 查看

2005-09-17 22:00 by idior

你举的例子是很不符合逻辑的,两个例子完全就不一样.anyway给你答案
class V
{
public int var;
}
class Program
{
static void Main(string[] args)
{
V v=new V();
Func f=(c,n)=>c.var=n;
f(v,10);
Console.WriteLine(v.var);
}
}
输出10

我不知道你的例子想说明什么问题. 至少从功能上看毫无意义,当然我想你的意图不是这个, 所以希望你举一个有意义的例子. 也就是说你想表明lambda表达式应该具有什么样的功能. 然后我尝试给出C#的实现. 欢迎你对lambda的讨论, 我也刚好尝试一下c#的lambda表达式到底能做到哪种程度.

这里再演示lambda表达式的一个功能:
static void Main(string[] args)
{
Expression> filter = n => (n * 3) < 5;

BinaryExpression lt = (BinaryExpression) filter.Body;
BinaryExpression mult = (BinaryExpression) lt.Left;
ParameterExpression en = (ParameterExpression) mult.Left;
ConstantExpression three = (ConstantExpression) mult.Right;
ConstantExpression five = (ConstantExpression) lt.Right;

Console.WriteLine("({0} ({1} {2} {3}) {4})", lt.NodeType,
mult.NodeType, en.Name, three.Value, five.Value);
}

再次强调:
1 .net的匿名delegate, 没有这个说法.只有匿名方法和delegate的概念.
2 .net的lambda表达式主要是为LINQ服务的.

#56楼 [楼主] 回复 引用 查看

2005-09-17 22:29 by idior

---------------
var是强类型的，是类型安全的。var主要与其它特性结合运用起来会非常方便，比如结合查询表达式，匿名类使用。
orcas也绝不是什么js. 希望大家了解以后再来谈，不要那么浮躁。

---
而且.net的匿名delegate根本算不上lambda。
---
没有匿名delegate这种说法。lambda表达式确实有很多的数学背景，但是从编程语言来说的是针对lisp中的lambda表达式的概念。

---
原来是会根据上下文自动推导，这种东西在ml语言里早就有了。但是对于c#来说看不出任何好处。
---
其实如果你什么都想自己推导自己做的话，也没必要学计算机了。
-------------------

不知道哪里有断张取义的地方. 我也想知道我哪里说错了,好承认错误.

lambda表达式在数学中的作用和在编程语言中的作用显然是不同的.
lambda表达式在c#中的作用就是方便的创建方法和Expression Trees,不是用来进行计算和证明的. 作为我个人就是从这个角度看lambda表达式的.

#57楼  回复 引用

2005-09-18 09:15 by [ IceSharK - PP.Poet ]

@castl

没激动呀有什么好激动的？

我只是在给“张三”说“李四”的事情

突然“王五”莫名其妙的杀了出来

把我吓了一跳

---------------------------------------------------

@刘典

你真的连我的话都听不明白？

是您主动发难的我很冤枉 555

“道不同不相为谋”不是针对您的您自做多情了

------------------------------------------------------

还有不要光说别人错了

请指出别人哪里错了如何改进

这样大家才能学习进步是吧？

您说对吧？祝您中秋快乐！

------------------------------------------------------

“评论根本没有带任何感情的倾向性”

这您就错了

人是有感情的所以人的评论都是有“感情”的

学文学的人都知道这样一条常识：

“绝对没有纯客观的描写”

------------------------------------------------------

最后借用 castl 的话

“呵呵，技术争论没必要那么激动。”

------------------------------------------------------

@idior

在贵宝地发了些非技术的回复请见谅

还有关于 SaveFileDialog 的问题

请参见相关回复

#58楼 [楼主] 回复 引用 查看

2005-09-18 12:44 by idior

@ [ IceSharK - PP.Poet ]
hehe,nothing.

#59楼  回复 引用

2005-09-18 14:55 by 刘典[未注册用户]

是我言语过激引起的，向大家道歉，我们不要争执了，毕竟来这里主要是讨论技术而不是吵架，言归正传吧。

public class C {
delegate void D(int p);
D f(out int o) {
return delegate(int p){ o = p; };
}
public static void Main(string[] argv) {
int a;
D d = new C().f(out a);
d(10);
System.Console.WriteLine(a);
}
}

我那ruby的例子写的有点不恰当，其实我就是问上面代码为什么不能通过编译。

#60楼  回复 引用

2005-09-18 14:56 by 刘典[未注册用户]

忘了说：祝大家中秋快乐。

btw：这里是cnblogs 很通过的一个名字为什么只专注.net技术呢？

#61楼 [楼主] 回复 引用 查看

2005-09-18 15:22 by idior

@刘典
其实你这个例子不好,有点考语法的意味,并没有涉及Lambda的具体应用而且我也给出了类似的解决方案. 我很想知道lambda表达式到底应该怎么玩, 希望你举个ruby或者Lisp下有意义的例子,我试试在c#能不能玩.

呵呵名字可能是dudu原来想法不是专注.net.

#62楼  回复 引用 查看

2005-09-18 21:18 by Ninputer

C#的Closure可能不能处理out，但我想原因可能不是因为参数在Stack上。当然，你不能说不支持这个就不是真的Lambda，没人定义Ruby的Lambda就是正宗Lambda。在早期理论中，正统的Lambda表达式根本没有传出参数这一概念。PS. 看看我的.NET Functional Programming方案——VBF吧。这是实现你所说特性的代码（C++/CLI描述）VBF可以实现的哦。
public ref class D: public UnaryByRefActionFunctor<int>
{
private:
interior_ptr<int> m_intRef;

public:
D(interior_ptr<int> a)
{
　　m_intRef = a;
}
virtual void Proc(int obj) override
{
　　*m_intRef = obj;
}
}

void Main()
{
　　int a;
　　D d = new D(&a);
　　d.Proc(10);
　　Console::WriteLine(a.ToString());
}

PS.过两天VBF就可以在SF.net下载了。

#63楼  回复 引用 查看

2005-09-18 21:44 by Ninputer

Lambda玩起来是比较容易让人吐血的，特别是……高阶函数

Func<Func<Func<T, T>, Func<T, T>>, Func<Func<T, T>, Func<T, T>>> PRED = n => n (g => k => (g(_1)) (u => PLUS (g (k))(_1))(k)) (l => _0)(_0)

C#是强类型的语言，再加上on-the-fly函数的限制（以后我会介绍这一Linq概念），因此我对上述表达式能否按我预期工作毫无信心。不过我有信心它能在VBF中实现！

#64楼 [楼主] 回复 引用 查看

2005-09-18 22:14 by idior

@Ninputer
可惜你玩的是VBF :( 不是CSharpF. 叫我学python没问题, 叫我去学VB总感觉划不来.

#65楼  回复 引用 查看

2005-09-19 08:31 by Ninputer

没人说VBF只能在VB中用啊，为了实现一些高级功能，我常常考虑C++/CLI + VBF呢。C# 3.0是2年后的东西，但VBF就是今天的东西，基于.NET 2.0的FP方案。我目前有3个Plan，第一个是函数组合、算子和高阶函数的实现，这是VBF的基础；第二个是基于VBF的查询系统，要实现表达式生成，如果顺利的话在3.0到来之前就可以享受强类型语法集成的查询；第三个计划是实现一个Parser框架，让人们可以在.NET轻松为自己的表达式或者脚本编写词法分析器。

#66楼  回复 引用

2005-09-19 08:48 by 刘典[未注册用户]

我记得原来看过关于Closure的一个非形式化的定义，基本是这样说的：Closure就是在一个lambda表达式产生proc的时候会携带他所处的环境，任何时候对这个lambda产生的proc进行求值的时候，在这个proc内部看来都是处在原来的环境里。
如果真是这样那为什么out参数和ref参数不能使用呢？我个人看法还是因为参数在stack上的关系，因为out或者ref参数就是指向stack上变量的指针，当函数返回是这些指针也就失效了。所以才不让我们在lambda里面使用out和ref参数。
这个例子是没啥实际意义，但研究一下更有利于我们了解.net内部的一些机制，这对我们使用.net还是有好处的，就象我们了解c++一些机制的内部原理能更有利我们使用c++一样。
ruby lisp等支持fp的语言都不支持out型参数：（，我在看看有没有别的办法。

#67楼  回复 引用 查看

2005-09-19 08:56 by Ninputer

C#的Closure用的是HelperClass来携带环境中变量的信息的，老实说这方法肯定有限制而且不会很高效。VB组正在研究新的方案，让我们期待吧:)

#68楼  回复 引用

2005-09-19 10:43 by 刘典[未注册用户]

我怀疑ms会为了支持 lambda和closure 在vm层加新指令。做一个东西出来然后不断加入新特性是ms的一贯风格，等臃肿不堪的时候就不管了，然后另起炉灶。

#69楼  回复 引用 查看

2005-09-19 12:02 by Ninputer

你太小看微软语言组了，至少他们想出的方案不会比你预想的要差。

#70楼 [楼主] 回复 引用 查看

2005-09-19 20:05 by idior

@刘典
有什么心得后共享一下 :) 我还很想看看在应用层lambda表达式能做些什么漂亮的活.

@Ninputer
对于expression tree,有没有什么具体的应用?

#71楼  回复 引用 查看

2005-09-20 08:29 by Ninputer

Expression Tree只有一个功能，就是远程查询。Function是无法序列化的，因此作远程查询也是跟本不可能，无法将规则进行传输。C#最大的一个语法糖就是将Expression Tree的生成做成从Lambda自动推导（编译期间完成）。

Func<int, bool> f = x => x > 15; //这个是函数
Expression<Func<int, bool>> ex = x => x > 15; //现在已经不是函数了

ex是一个用对象层次表达的树，其中记录的操作的类型，如Op.Greater，和两个操作数的类型。其余信息就是两个操作数的Expression对象。有了这种东西，远程查询就成为可能了。

PS.做点广告，我的VBF Expression Tree和Function是同步生成，当写下
Dim f As UnaryPredicate(Of Integer) = PInt > 15
将同时得到f.Proc（函数）和f本身（Expression Tree），因此可同时做本地查询或远程查询。

#72楼  回复 引用 查看

2005-09-20 10:21 by Cavingdeep

@刘典

Hi，关于你说C#的anonymous method不支持out型参数的问题，你可以稍微变通一下，你可以这样写：

D f(out int o) {
int oCopy = 0;

D d = delegate(int p){ oCopy = p; };

o = oCopy;

return d;
}

其实正宗的OOP是不需要也不应该支持out或ref这种类型的参数的，C#当初是为了方便支持P/Invoke才添加进C#的，像Java就没有out或ref这种类型的参数。一般我们用纯托管代码做开发的时候应当避免使用这类参数的设计。另外FP同OOP一样，也是不需要也不应该有这种类型的参数的。

#73楼  回复 引用 查看

2005-09-20 10:31 by Cavingdeep

@刘典

哦，我上面的方案有问题，我想我知道为什么out或ref不支持了。你单步调试一下就知道了！：）

#74楼 [楼主] 回复 引用 查看

2005-09-20 10:32 by idior

out ref 有点二级指针的味道.
比如两个字符串swap, 用ref就很简单, 而在没有ref的java下,就很麻烦.

#75楼  回复 引用 查看

2005-09-20 11:10 by Cavingdeep

str1, str2 = str2, str1

这个够简单的了吧？如果是Python或Boo的话。：）

#76楼  回复 引用

2005-09-20 11:56 by cmz[未注册用户]

大家把本质的东西学好就行了，这些功能只不过是帮你简化代码而已

#77楼 [楼主] 回复 引用 查看

2005-09-20 12:02 by idior

这些特性分开时就象语法糖, 好玩而已, 但是当它们组合在一起制造出LINQ时,带来的变化和影响都将是巨大的.
当anders在PDC展示LINQ的时候, 全场很多人站了起来并说道"Oh my god".

#78楼  回复 引用 查看

2005-09-20 13:31 by Cavingdeep

能否详细讲一下Anonymous Type，这个要比Anonymous Method更吸引人！：）

我想知道的是Anonymous Type如何实现其他接口或继承一个其他类，或者同时做这两件事。

比如Java是这样的：

new ObjectType() {...}

#79楼 [楼主] 回复 引用 查看

2005-09-20 14:07 by idior

@Cavingdeep
java中的叫Anonymous Class. 它只是没有实例的名字,类型的名字是有的.
而LINQ中的叫Anonymous Type.它是没有类型的名字.

Anonymous Type用于方便的返回查询结果.Anonymous Type通常就是一些数据的简单包装,就像一个盒子. 如果这个结果很快就被用掉, 那为此创建一个class显得很麻烦,于是LINQ就引入了这么一个概念.比如下面这个例子:

var expr = people.Select(p => new {
p.Name, BadCoder = p.Age == 11
});

foreach (var item in expr)
Console.WriteLine("{0} is a {1} coder",
item.Name,
item.BadCoder ? "bad" : "good");

而且LINQ中之所以引入var这个功能,很大程度上就是因为Anonymous Type的存在,
既然没有类型名我如何声明该类型的变量?所以需要用var来让编译器自己推导.

是不是有点失望, 其实Anonymous Method和Anonymous Class倒是更接近些.

#80楼  回复 引用 查看

2005-09-20 14:24 by 刘典

@Cavingdeep
我同意你的看法，支持oo语言根本就不应该有out和ref类型，oo语言变量本身就是一个ref，我们完全可以用改变变量所制向的对象的状态的方法来实现out， c#的out唯一的作用也就是针对那些只能放到stack上的基本类型，而且我觉得一个oo结构的软件如果出现了对基本类型的直接操作90%的情况下都是设计出了问题。

-----------------------------------
你忽略了一个问题，我通过f返回的D类型的delegate调用匿名方法的时候，只是执行方法里的 oCopy = p， o = oCopy只有在执行f的时候才会执行到。你的代码并没有实现在f所返回的delegate里修改out参数的功能 :)
也就是说只修改了ocopy 而没有修改o。

#81楼  回复 引用 查看

2005-09-20 14:25 by Cavingdeep

Thanks, got it!

的确有点失望，其实delegate没有interface好用，同样Anonymous Method没有Anonymous Class好用。:(

另外关于LINQ，从所有这些新元素上可以体现其实作者在做这些的时候脑子里想的都是如何简化数据操作，也就是数据导向。对于纯粹做OOP的人我估计他们并不太喜欢，包括我在内！^_^

#82楼  回复 引用 查看

2005-09-20 14:35 by Cavingdeep

◎刘典

对，所以有问题:D 其实就算支持，用起来还是不方便，比如在Python中我可以这样写：

def Sum(a):
return lambda b : a + b

result = Sum(1)(2)

结果为3。

但是上面这一小段要放在C# 2.0中写就麻烦死了，还要再声明一个委托。不过从长远来看，C#这种静态类型语言（Statically Typed）的可维护性要比其他动态类型语言（Dynamically Typed）高！其实C#就是C#，我并不赞成将C#“整容”一个不是C#的C#，所以我并不欣赏LINQ或C# 3.0目前的这种趋势。

#83楼  回复 引用 查看

2005-09-20 14:57 by 刘典

"再对比一下java那边, 似乎还没听到6.0的什么消息, 不知道他们将如何应对.net的下一波冲击!"
其实java早在.net诞生之前就已经有了lambda和closure了，只是这些特性都是“对象级别”的，而且sun也没有宣传，知道的人不多。因为java是纯oo语言，不存在独立的方法或者函数，他的“lambda”产生的是匿名对象，而不是方法，至于java的“closure”也是对象级别的，匿名对象会自动携带他所处的对象环境，运行一下下面的代码就知道了，注意那个匿名对象中使用的变量s ，他是外部类的一个成员，可以在匿名类里直接使用。
---------------------------------------------------------------------------------------
interface I {
void show();
}

public class C {
private String s;

public C(String s) {
this.s = s;
}

public I f() {
return new I() { //这里实例化一个实现接口I的匿名类
public void show() {
System.out.println(s); //这里可以直接使用外部类的成员s
}
};
}
public static void main(String[] argv) {
C c1 = new C("Hello C1");
C c2 = new C("Hello C2");

I i;
i = c1.f();
i.show();
i = c2.f();
i.show();
}
}
-----------------------------------------------------------------
执行结果：

D:\work\javaapp>java C
Hello C1
Hello C2

c1.f返回的匿名对象自动携带c1 ，c2也同样，所以匿名对象里才可以直接使用s。

#84楼 [楼主] 回复 引用 查看

2005-09-20 15:04 by idior

Func f=(a,b)=>a+b

var result=f(1,2)
LINQ中内置了一些delegate
http://idior.cnblogs.com/archive/2005/09/18/239342.html">http://idior.cnblogs.com/archive/2005/09/18/239342.html

#85楼  回复 引用 查看

2005-09-20 15:16 by 刘典

"而且LINQ中之所以引入var这个功能,很大程度上就是因为Anonymous Type的存在,
既然没有类型名我如何声明该类型的变量?所以需要用var来让编译器自己推导. "

的确是这样，光让var去自动推导int float这些简单类型的确没有意义，主要用途还是用在匿名方法上，让我们不用返回一个匿名方法的时候还要显示的去声明一个和匿名方法原形相符的delegate。
这让我想起了我以前设计软件框架的时候出现过的一种现象：加入某重看似很好的特性，但是这个特性的引入也带来了一些问题，为了解决这个问题又引入了新的特性，结果问题被解决的同时又引入新的问题，然后再引入新的特性解决之。。。。。。

我感觉c#似乎也有点这个味道了。 java在这方面一直很谨慎，他引入的新特性全能够和旧有的东西和谐相处。比如Anonymous Class，他既带来了Anonymous Method的好处，还没有他的缺点（必须伴随一个原形定义）。

#86楼  回复 引用

2005-09-20 15:38 by ray_linn[未注册用户]

这。。。感觉就象 Java的 Groovy。。。。啊！

#87楼  回复 引用 查看

2005-09-20 16:23 by 刘典

说到 Groovy想起来了。看看下面的代码:

class Foo {
doSomething() {
data = ["name": "James", "location": "London"]
for (e in data) {
println("entry ${e.key} is ${e.value}")
}
}

closureExample(collection) {
collection.each { println("value ${it}") }
}

static void main(args) {
values = [1, 2, 3, "abc"]
foo = new Foo()
foo.closureExample(values)
foo.doSomething()
}
}

#88楼  回复 引用 查看

2005-09-21 09:04 by Ninputer

匿名类型的一个问题：如果有一堆Tuple都具有比方Name这个属性，但是其他属性却不相同，于是就都不是一个类型的，如：
var o1 = new {Name = "Obj1", Age = 12}
var o2 = new {Name = "Obj2", ID =13, Company = "CS&S"}
var o3 = new {Name = "Obj3", Address = "Beijing" }

很明显，o1 o2 o3具有不同的（匿名）类型，无法用一个基类或者接口来通用他们，即使他们都有Name属性。因为无法让匿名类实现接口。
那么有什么办法能解决吗？如何用一个IHasName接口来处理所有有Name的Tuple呢？请继续关注我的VB9系列！

#89楼  回复 引用 查看

2005-09-21 10:07 by 刘典

@ Ninputer

我越来越感觉到现在的oo思想存在很大问题，人的思维模式是从事物属性中总结出概念，而现在oo却是先有概念（类），然后考虑他有什么属性，和人的基本思维模式不同。

所以我觉得一个类的层次关系不应该一开始就定下来，而是应该根据使用情况自动推导。比如还是那个name属性的例子，开始类不实现任何接口，而是在使用类的时候自动推导出他有一个IHasName的接口。

#90楼  回复 引用 查看

2005-09-21 10:26 by Ninputer

有一句话你听过吗Static typing when possible, dynamic typing when needed. 你的想法是当今许多动态语言都支持的Duck Typing想法，就是说用行为来作为使用的依据而不是类型的声明。

#91楼 [楼主] 回复 引用 查看

2005-09-21 11:05 by idior

ms向来喜欢搞没有行为的哑数据，这也是我非常不喜欢的。
DLINQ还是以数据为中心，就像andser自己说的是ado.net的升级。

从数据库中查到所需要的数据（没有行为的实体），然后再对数据操作。贫血的对象！我不觉得它像一个orm。以后应该有人基于LINQ做一个LINQORM

#92楼  回复 引用 查看

2005-09-21 15:58 by Ninputer

刘典总以为匿名方法是个委托，所以要原型什么的，我估计很多人都这样错误理解。匿名方法就是个方法，不是委托，所以不能叫匿名委托。委托只是承载这个匿名方法（因为匿名，所以就没有办法直接调用）。为匿名方法声明一个委托是本末倒置的，匿名方法的本意是为需要委托的上下文声明一个函数。
PS.不要只看到C#，VB9的嵌套函数既没有委托，也可以实现Closure。

#93楼  回复 引用

2005-09-21 16:20 by 刘典[未注册用户]

closure其实和匿名方法本来就没有什么关系，都可以独立存在。

我觉得匿名方法和匿名委托的叫法都没错误，因为他们的确都没有名字^_^ ，你说一个委托来承载这个匿名方法，但是这个委托的类型本身也没用delegate关键字显示声明，他的类型是自动推导出来的，说他匿名有何不可？

#94楼  回复 引用

2005-09-22 11:40 by dasney[未注册用户]

再好的语言也不过是玩个把戏而已。
能解决实际问题才是硬道理。

#95楼  回复 引用

2005-09-22 15:01 by 刘典[未注册用户]

@dasney

解决问题的是人，而不是工具，但是好的工具可以提高效率。如果你认为这仅仅是把戏的那说明你还没理解什么是编程。

#96楼  回复 引用

2005-09-22 17:17 by 默默无闻[未注册用户]

人家在做事情，一群人在这里评，我不相信可以评出另一个c#出来

#97楼 [楼主] 回复 引用 查看

2005-09-22 17:17 by idior

@刘典
agree with u

#98楼  回复 引用

2005-09-23 09:02 by 刘典[未注册用户]

这是交流。
大师么也是要互相交流才发明出更好的语言的，我们不能发明语言，但可以通过交流更好的使用语言。

#99楼  回复 引用 查看

2005-09-24 13:28 by 蛙蛙池塘

to 刘典，你说的ML是不是那个写神经网络的M语言呀。

#100楼  回复 引用

2005-09-27 20:09 by 一个过客[未注册用户]

建议大伙都去用JAVA！

#101楼  回复 引用

2005-11-20 22:45 by wuxin[未注册用户]

太复杂了,还不如加上多重继承有用

#102楼  回复 引用

2005-12-22 09:51 by hel420[未注册用户]

唉，失望！搞什么花招，C＃是C＃要想搞别的花招就去加别的语言。不喜欢这种用法。

#103楼  回复 引用 查看

2005-12-28 11:36 by dasney

@刘典
我无意跟任何人争辩语言的优劣，我也清楚地知道在计算机领域内争辩任何问题都不是我的一贯做法，因为我相信，在我们的国家，在这样一个技术被外国人垄断的环境下，我们的一切争吵都只是人民币的陪葬品！
不得不承认，我的“把戏”二字把部分高手激怒了，如果仅仅是因为这个原因，我希望大家能够表示谅解，因为，这个领域对我是陌生的，我仅仅是偏离地认识了这个问题。
很感谢指出我的缺点，“还没理解什么是编程”用在这里，最恰当不过！

#104楼  回复 引用 查看

2006-06-10 08:22 by Laser.NET

@刘典
“我越来越感觉到现在的oo思想存在很大问题，人的思维模式是从事物属性中总结出概念，而现在oo却是先有概念（类），然后考虑他有什么属性，和人的基本思维模式不同。

所以我觉得一个类的层次关系不应该一开始就定下来，而是应该根据使用情况自动推导。比如还是那个name属性的例子，开始类不实现任何接口，而是在使用类的时候自动推导出他有一个IHasName的接口。”

深有同感！

#105楼  回复 引用 查看

2006-06-12 16:30 by 辉郎

我注意到搂主提到“局部变量的声明变得非常方便”，是不是属性成员或全局变量就不能用var了？

#106楼 [楼主] 回复 引用 查看

2006-06-12 16:34 by idior

@辉郎
对仅限于局部变量，让编译器推导类型方便点而已

#107楼  回复 引用

2006-06-15 11:02 by mooniscrazy[未注册用户]

比较语言是没有什么意义的。这容易引起毫无意义的争论。
c#3.0引入的功能是好是坏现在还难以定论。语言是变复杂了，但是毫无疑问，这些新功能非常有用。
以后的代码，肯定会变得更加简捷。能够节省大量的时间。
这就够了。不要去争论c#的发展方向，那不是我们所能控制的。

#108楼  回复 引用

2006-07-12 10:32 by ofei[未注册用户]

idior
从数据库中查到所需要的数据（没有行为的实体），然后再对数据操作。贫血的对象！....

数据库只能存数据...
通过sqlmetal生成实体类的时候使用了partial关键字可以附加实体的行为的...
不知道我的说法对否

#109楼  回复 引用

2006-07-22 14:48 by gis_yy[未注册用户]

不管怎样，我喜欢新东西，有新东西我们才有发展的空间，不管是好是坏，关键是我们自己要吸收，再自己创新。

#110楼  回复 引用

2006-09-25 10:53 by canlove[未注册用户]

提个问题,别太介意
请问各位说得天花乱坠的高手们:
你们都是做什么的?
如果是搞开发的,是不是会觉得CodeSmith这样的工具也只是小儿科而已
如果是搞项目管理的?不太可能吧
如果是搞科研的?应该没这么轻松啊
如果是搞学术的?有可能吧
那你们究竟都是搞什么的,让我死的明白啊

#111楼  回复 引用

2007-06-12 18:47 by partpass[未注册用户]

正在看这个..感觉变的太多了.
更新好快..

#112楼  回复 引用

2007-06-22 09:27 by ejiyuan

我是一个初学者,不敢妄加评论,其实我觉得C#本来就是拼拼凑凑而来的语言,foreach是借用vb的,现在又在js中弄来一个 var.目的很明确,就是无论是你学什么语言的只要想转到c#都能变得很容易...都能感觉很亲近

#113楼  回复 引用

2007-07-05 17:08 by oldrev[未注册用户]

不要害怕关键字的增加，本来高级语言就是为了人类的方便服务的，否则C中一个for就能处理所有的情况，为什么还要 do和while?

#114楼  回复 引用

2007-07-10 13:09 by even[未注册用户]

以下说的一点道理也没有！
"以上的介绍将各个新增功能分开逐一介绍, 表面看了好像仅仅是增强了一些新的语法, 增加了C#语言的灵活性, 甚至会有人认为此举得不偿失, 但是最重要的概念不是在于这些小的语言点,而是通过它们的合作而产生的LINQ. 将类似关系型(实际还是面向对象的)的语言引入到C#中,大大增强了C#对于数据的操作能力(内存数据---集合, 外部数据--DataBase,XML ).

Linq何时才能用? 虽然在语法层面Linq加入了很多新的内容, 但是在做完上面的范例之后, 你会发现Linq中并没有在CLR底层加入什么新的元素. 所有新的功能仍然是建立在泛型的基础上,然后由编译器完成大部分的代码转化和生成. 以上的程序集在reflector中都是可以被反编译的,并没有什么新的底层元素不可被识别. 因此,个人估计只要MS不断推出Linq新的测试版本, 我想Linq并不需要等到Orcas才能发布.或许在.Net 2.1时就可以正式发布了. Orcas应该不止是Linq这么简单, 它应该会在底层加入新的元素, 这样才叫主版本的变化嘛,就像2.0加入了泛型.

推而广之, 如果你想为.Net增强新的功能,比如加入AOP的功能, 那么你也可以考虑实现自己的一套增强型编译器. 不过C++好像就是这样被毁掉的. 真怕以后出现n多版本的C#."

#115楼  回复 引用 查看

2007-08-26 16:00 by Artech

现在来看这些评论还满有意思的：）

Feedback

#2楼[楼主] 回复 引用 查看

#5楼[楼主] 回复 引用 查看

#9楼[楼主] 回复 引用 查看

#15楼[楼主] 回复 引用 查看

#19楼[楼主] 回复 引用 查看

#29楼[楼主] 回复 引用 查看

#32楼[楼主] 回复 引用 查看

#42楼[楼主] 回复 引用 查看

#51楼[楼主] 回复 引用 查看

#55楼[楼主] 回复 引用 查看

#56楼[楼主] 回复 引用 查看

#58楼[楼主] 回复 引用 查看

#61楼[楼主] 回复 引用 查看

#64楼[楼主] 回复 引用 查看

#70楼[楼主] 回复 引用 查看

#74楼[楼主] 回复 引用 查看

#77楼[楼主] 回复 引用 查看

#79楼[楼主] 回复 引用 查看

#84楼[楼主] 回复 引用 查看

#91楼[楼主] 回复 引用 查看

#97楼[楼主] 回复 引用 查看

#106楼[楼主] 回复 引用 查看

日历

公告

与我互动

搜索

常用链接

留言簿

我参加的小组

我参与的团队

随笔分类(225)

随笔档案(204)

文章档案(45)

相册

Friends

Resource

SOA

Util

积分与排名

最新评论

阅读排行榜

评论排行榜

#2楼 [楼主] 回复引用查看

#5楼 [楼主] 回复引用查看

#9楼 [楼主] 回复引用查看

#15楼 [楼主] 回复引用查看

#19楼 [楼主] 回复引用查看

#29楼 [楼主] 回复引用查看

#32楼 [楼主] 回复引用查看

#42楼 [楼主] 回复引用查看

#51楼 [楼主] 回复引用查看

#55楼 [楼主] 回复引用查看

#56楼 [楼主] 回复引用查看

#58楼 [楼主] 回复引用查看

#61楼 [楼主] 回复引用查看

#64楼 [楼主] 回复引用查看

#70楼 [楼主] 回复引用查看

#74楼 [楼主] 回复引用查看

#77楼 [楼主] 回复引用查看

#79楼 [楼主] 回复引用查看

#84楼 [楼主] 回复引用查看

#91楼 [楼主] 回复引用查看

#97楼 [楼主] 回复引用查看

#106楼 [楼主] 回复引用查看