黄季冬

今天早些时候，塞班基金会正式宣布，其智能手机操作系统Symbian OS的内核及中间件和大部分软件都将以不同的license开放源代码，用户可以下载和修改它们，这次开放的源代码超过4000万行。这次开源行动无疑会吸引更多的开发者到Symbian的marketplace中来，这让近来一直收到iphone和android打压的Symbian OS又找回了些许空间。

全球现在约有3.3亿Symbian智能设备在使用，但是Symbian的闭塞一直受到各方开发者的诟病，此次开源能否挽回Symbian的颓势还需要时间的检验，毕竟市场不是一两天就能建立起来的。

消息来源：

http://www.pcworld.com/article/188521/symbian_os_now_fully_open_source.html

昨天微软终于（突然）发布了Windows Mobile SDK 6.5，有中文版可供下载，不过遗憾的是仍然不支持VS2010。详见：

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=c5241738-0fe6-4396-a4e5-5a516deb1bc5

更新：Waggener Edstrom, 微软的公关代理，表示说 "on Friday, January 22nd Microsoft prematurely posted a version of an upcoming Windows Mobile 6.5 SDK to a public facing Web page. While the SDK was not announced or promoted, it was discovered and generated questions from the community. The beta SDK has since been removed. To provide the best experience possible for Windows phone developers, the SDK will be reposted once final testing has been conducted. We apologize for any inconvenience".

C#4.0新特性之(四)新的LINQ扩展方法-Zip()

1.简介

　　所谓zip（中文有拉链的意思），就是像拉链一样，把两个list缝合在一起。Python中有个zip函数可以用来方便的合并两个或者多个集合，例如：

 以上代码会打印出

Freesc Huang
Joshua Guan
Ken Wang

在C#4.0中，我们可以看到一个类似的扩展函数^[1]：

代码2

        //
        // Summary:
        //     Merges two sequences by using the specified predicate function.
        //
        // Parameters:
        //   first:
        //     The first sequence to merge.
        //
        //   second:
        //     The second sequence to merge.
        //
        //   resultSelector:
        //     A function that specifies how to merge the elements from the two sequences.
        //
        // Type parameters:
        //   TFirst:
        //     The type of the elements of the first input sequence.
        //
        //   TSecond:
        //     The type of the elements of the second input sequence.
        //
        //   TResult:
        //     The type of the elements of the result sequence.
        //
        // Returns:
        //     An System.Collections.Generic.IEnumerable<T> that contains merged elements
        //     of two input sequences.
        public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, 
                                           IEnumerable<TSecond> second, 
                                           Func<TFirst, TSecond, TResult> resultSelector);

它可以用来合并列表，并且提供了自定义的组合规则:Func<TFirst, TSecond, TResult> resultSelector。

2.示例

　　下面是一段和代码1功能一样的C#4.0程序： 

代码3

            List<String> firstName = new List<String> { "Freesc", "Joshua", "Ken" };
            List<String> lastName = new List<String> { "Huang", "Guan", "Wang" };
            foreach (var name in firstName.Zip(lastName, (fname, lname) => fname + " " + lname))
            {
                Console.WriteLine(name);
            }

 

3.Zip()的实现

　　在python中要实现一个zip，很简单(这里省去了异常处理)，只需要用到三个内建函数，iter,map和next:

类似的，如果不考虑异常处理，C#的Zip扩展方法可以是如下实现^[2]：

代码5

    static class Enumerable
    {
        public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first,
            IEnumerable<TSecond> second,
            Func<TFirst, TSecond, TResult> func)
        {
            var ie1 = first.GetEnumerator();
            var ie2 = second.GetEnumerator();

            while (ie1.MoveNext() && ie2.MoveNext())
                yield return func(ie1.Current, ie2.Current);
        }
    }

4.总结

　　Zip作为LINQ系统的新成员，提供了一种自由组合两个集合的方式，要注意的是，这个Zip使用时要求两个序列的长度一致，如果不一致，它会yield较短的长度。这一点和python中的zip是一样的。另外，您不妨可以试着写一个组合多个集合的MultiZip方法，也许它对您更加有用;-)

5.引用

[1] http://msdn.microsoft.com/en-us/library/dd267698(VS.100).aspx

[2] http://community.bartdesmet.net/blogs/bart/archive/2008/11/03/c-4-0-feature-focus-part-3-intermezzo-linq-s-new-zip-operator.aspx

AUTHOR: Freesc Huang @ CNBlogs

C#4.0新特性之(三)协变与逆变

1.C#3.0以前的协变与逆变

　　如果你是第一次听说这个两个词，别担心，他们其实很常见。C#4.0中的协变与逆变^[1]（Covariance and contravariance）有了进一步的完善，主要是两种运行时的（隐式）泛型类型参数转换。简单来讲，所谓协变(Covariance)是指把类型从“小”升到“大”，比如从子类升级到父类；逆变则是指从“大”变到“小”，两者各有不同的条件和用途。下面的例子演示了C#3.0以前对协变与逆变支持^[2] ： 

代码1

       public class Animal { }
       public class Cat : Animal { }

       public delegate Animal AniHandler(Animal a);
       public static Animal AniMethod(Animal a) { return null; }
       public static Cat CatMethod(Object o) { return null; }

       public static void TestCovariance()
       {
           AniHandler handler1 = AniMethod;
           AniHandler handler2 = CatMethod;//这里是合法的
       }

　　这里的CatMethod虽然不是严格满足委托AniHandler的签名，但它被用作AniHandler是合法的，在协变（Cat->Animal）和逆变(object->Animal)的作用下，委托指向的方法中，传入的参数可以是一个大的，宽泛的类型，而返回出来的结果可以是一个更小的，精确的类型（子类），因为它包含了更多的信息。注意这里是站在方法里面这样说的，而在调用者使用方法的角度，恰恰是相反的，在调用方法时，参数可以是一个“小”的子类，而返回值可以用作一个“大”的父类，如下面的调用是合法的：

　　呵呵，听上去有点晕，现在我要试着把问题简洁地表达清楚。无论是协变还是逆变，它都是为了让这样一个非常合理的事实成立：如果提供的类型信息比所需要的类型信息多（而不是相等），那这当然是可以的。在代码1的例子中，AniHandler委托需要一个Animal作为返回值，但是我返给它一个Cat，Cat包含了Animal的所有特征，这当然是可以的，这就是协变；同时AniHandler需要一个Animal作为参数，为了让函数获得的信息比要求的多，我可以只要求传进来一个object，这也当然是可以的，这就是逆变。

2.C#4.0中的协变

　　我们先来看一下和谐的协变是如何发生的。C#4.0中的协变与C#3.0中的宽松委托非常类似，新的C#协变特征还体现在泛型接口或者泛型委托的类型参数上。还是以经典的Animal和Cat为例，在你看过上面代码1之后，既然Cat CatMethod()可以被用作Animal AniHandler，那么你完全有理由相信下面的代码在C#3.0中也是合法的：

代码3

        delegate T THandler<T>();

        static void Main(string[] args)
        {            
            THandler<Cat> catHandler= () => new Cat();
            THandler<Animal> aniHandler = catHandler;//Covariance 
        }

 

 　　很遗憾，您错了，在C#3.0中，上面的代码不能通过编译，你会被告知这样的错误：

　　时代进步了，现在在C#4.0的编译器是支持上面的写法的。你只需要在声明THandler的类型参数前加一个out关键字即可： 

　　单独的使用一个关键字而不是直接允许隐式转换也是为了类型安全的考虑。所以当你写下out的时候，就应该知道可能发生的Covariance。

3.C#4中的逆变

　　我们继续使用Animal和Cat的例子，在VS2008中，以下的代码不能通过编译： 

代码5

       delegate void THandler<T>(T t);    
       public static void TestContravariance()
       {
           THandler<Animal> aniHandler = (ani) => { };
           THandler<Cat> catHandler = aniHandler;
       }

　　而在VS2010中，呃，同样不能。呵呵，其实就差一点点，这里如果在类型参数T前面加上关键字“in”，即delegate void THandler<in T>(T t);就可以实现Cat->Animal的Contravariance。

4.总结

　　C#4中的协变和逆变使得泛型编程时的类型转换更加自然，不过要注意的是上面所说的协变和逆变都只作用于引用类型之间，而且目前只能对泛型接口和委托使用。一个T参数只能是in或者是out，你如果即想你的委托参数逆变又想返回值协变（如代码1所示），是做不到的。

5.引用

[1] http://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)

[2] http://msdn.microsoft.com/zh-cn/library/ms173174(VS.80).aspx

Author: Freesc Huang @ CNBlogs

 C#4.0新特性之(二)命名参数，可选参数与COM互操作

1.简介

　　之前C#（2.0）和java一样是一门的纯粹的面向对象的语言，他们都使用重载而不是可选参数。但是实际上使用的其他外部程序，COM组件却经常不要求指定所有参数（这在很多VC，VB编写的组件或者操作IronPython的对象的时候很常见，他们一直使用可选参数）。这会导致一个C#程序员不得不用Type.Missing塞满整个参数列表。不过C#4.0终于支持命名参数/可选参数了。程序员可以在方法调用的时候通过命名参数指定可选参数。而这一切都是为了让.Net 4.0的动态语言运行库（DLR）在动态绑定的时候具有更好的兼容性。

2.命名与可选参数

　　这个对C#来说是又一个新特征，但对C++，VB，Python etc. 的程序员来说这只是很自然的一个特征。C# 4.0种的可选参数和其他语言中的用法大致相同，这里不需要VB中额外的关键词修饰，也不能像C++中只用点点点来表示可以无视，倒是和python比较像，下面的声明是合法的：

可选参数Foo

        static void Foo(int a, String s = "i'm a string", dynamic b =null, MyClass c = null)

简单来讲，C#4.0中使用可选参数必须遵循以下几条原则：

0).可选参数必须有个编译时常量作为其默认值。如果是除String之外的引用类型（包括那个特殊的dynamic类型），默认值只能是null。下面的声明是不能通过编译的：

代码

        static void Foo(int a, String s = "i'm a string", dynamic b = 2, MyClass c = new MyClass())

1).可选参数必须从右往左出现在参数列表中（必须后出现），可选参数右边的参数（如果有的话）必须是可选参数。下面的声明是不能通过编译的：

代码

        static void Foo(String s = "i'm a string", int a, dynamic b = null, MyClass c = null)

 2).可选参数的赋值必须通过命名参数的方式指定，即必须使用可选参数的参数名称对其进行赋值。而非可选参数则不一定要用命名参数。如下的调用都是合法的：

Foo calls

            Foo(2);
            Foo(a: 2);
            Foo(2, s: "hello", b: 3.14);
            Foo(2, s: "hello", b: 3.14, c:new MyClass());
            Foo(2, c: new MyClass());

 特别的，一旦调用方法时使用的是命名参数，则命名参数的位置可以是任意顺序，如下的调用是合法的： 

代码

            Foo(b:3.14, c:new MyClass(), a:2);

唯一的影响就是上述调用中会对b先求值，然后再是c和a。函数总是按照参数出现的顺序进行求值操作的。 

　　另外，可选参数不仅适用于普通的方法，还适用于构造器，索引器中，本质上它们没有什么不同。

3.可选参数与重载决策

　　毫无疑问，命名参数和可选参数让CLR在方法的重载决策（overload resolution）变得稍微复杂了一些，不用担心，这里你只需要搞清楚重载决策的下面几个特点就可以了：

0).在带可选参数的方法签名中，重载决策不会认可被可选参数代替的重载版本，比如下面两个声明：

　　如果按照以下方式调用，编译器会提示你它已经被上面两个方法confused了：

1).在调用方式同样合法的情况下，重载决策会优先选择不带可选参数的重载版本。比如下面两个方法：

　　如果使用以下方式调用：被调用的会是void Foo(int a);这个版本：

2).在调用方式同样合法的情况下，重载决策会优先选择类型最为匹配（最易转化）的重载，例如下面两个方法：

 　　Foo(2)和Foo(a:2)都将调用前一个方法，因为int到byte是值类型之间的转化，其代价要比从int转到object的代价低。

4.C#4.0中的COM互操作

     在上一篇文章中提到的动态类型绑定和本文前面提到的命名参数，可选参数都为CLR的COM互操作提供了便利。有了动态类型，访问COM对象时不必再对返回的COM对象进行显式的类型转换了，因为返回的是一个dynamic类型的对象，我们可以直接在它上面调用方法/属性/索引器等，例如excelApp.Cells[row,column].Value = "some value"; 这里的Cells[row,column]返回的是一个dynamic类型的对象，而之前都是返回的object需要显式转换才能操作它，比如：((Excel.Range)excelApp.Cells[row,column]).Value = "some value";

     而有了可选参数，广大程序员们也不必再猛力用Type.Missing填充整个参数列表了，比如Office14的Excel.ApplicatioinClass中就利用了可选参数定义了一个intersect方法：

代码

public virtual Range Intersect(Range Arg1, Range Arg2, object Arg3 = Type.Missing, object Arg4 = Type.Missing, object Arg5 = Type.Missing, object Arg6 = Type.Missing, object Arg7 = Type.Missing, object Arg8 = Type.Missing, object Arg9 = Type.Missing, object Arg10 = Type.Missing, object Arg11 = Type.Missing, object Arg12 = Type.Missing, object Arg13 = Type.Missing, object Arg14 = Type.Missing, object Arg15 = Type.Missing, object Arg16 = Type.Missing, object Arg17 = Type.Missing, object Arg18 = Type.Missing, object Arg19 = Type.Missing, object Arg20 = Type.Missing, object Arg21 = Type.Missing, object Arg22 = Type.Missing, object Arg23 = Type.Missing, object Arg24 = Type.Missing, object Arg25 = Type.Missing, object Arg26 = Type.Missing, object Arg27 = Type.Missing, object Arg28 = Type.Missing, object Arg29 = Type.Missing, object Arg30 = Type.Missing);

 换做以前要手动指定这三十个参数的确是一件抓狂的事情。

      在性能方面，由于C#4种编译器可以把PIAs按需部分编译到你的程序集中，不必每次都完全load这组庞大的互操作程序集，这对提高COM交互性能很有帮助。另外还有一个语法糖就是在COM调用的时候可以不使用ref传递参数，这避免了程序员自行创建临时变量来hold这些参数，不过这里不使用ref并不代表不按引用传递而按值传递，实际上C#编译器会自行帮你创建临时变量并任然按引用把参数传递给调用者。

5.总结

     C#4.0中很大一部分特征弥补了它之前的一些令开发者不爽的地方，无论是动态类型还是可选参数，新的C#让那些和各种组件（COM,IronPython etc.）打交道的程序员获得一定程度的解脱。C#越来越变得以人为本，更确切地，以程序员为本。

Author: Freesc Huang @ CNBlogs