Essential .NET读书笔记

终于看完了Don Box的<<Essential .Net>>，感触良多，真的是一本好书！

由C#的IDispose接口而想到

C#的using语句是一种确定性析构的实现，来实现类似C++析构函数的功能，在对象不再需要时进行清除工作。但这种语法结构不如C++的析构函数清晰和优美。

using(T obj1=new T(), obj2=new T())
{

}

这里限制obj1和obj2必须是同一个类型，而且要求程序员明确给出每个变量的作用范围，实际上，CLR是可以确定每个对象的作用范围的，在C#的垃圾回收技术中，就利用了CLR来确定对象的作用范围。

{

       Object r1 = new object();

       Object r2 = new object();

       System.GC.Collect();

       r2.ToString();

}

在第三句话进行垃圾回收时r1将会被回收掉，尽管从语义的角度讲r1仍处在作用范围内。

 

今天看书，看到C#的接口实现，感觉C#的语法是否有点过于复杂了。先看下面的一段代码

    public interface IVehicle

    {

        void start(); void stop(); void turn();

    }

    public class Base : IVehicle

    {

        void IVehicle.start()

        {

            Console.WriteLine("Base.start");

        }

        public void stop()

        {

            Console.WriteLine("Base.stop");

        }

        public virtual void turn()

        {

            Console.WriteLine("Base.turn");

        }

    }

 

    public class Derive1 : Base

    {

        //非法，不能覆盖不存在的方法

        //public override void start() { }

 

        //非法,Base.stop不是虚函数

        //public override void stop() { }

 

        //合法，替代Base.turn和IVehicle.turn

        public override void turn()

        {

            Console.WriteLine("Derive1.turn");

        }

    }

 

    public class Derive2 : Base, IVehicle

    {

        //合法，重新实现IVehicle

        void IVehicle.start()

        {

            Console.WriteLine("Derive2.start");

        }

        //合法,重新实现IVehicle

        public void stop()

        {

            Console.WriteLine("Derive2.stop");

        }

 

        //合法，替换Ivehicle.turn（但不替换Base.turn）

        public void trun()

        {

            Console.WriteLine("Derive2.turn");

        }

}

 

在Main函数中进行如下调用

            Derive1 d1 = new Derive1();

            Console.WriteLine("调用Derive1的成员”);

           // d1.start();//非法调用

            d1.turn();//调用Derive1.trun

            d1.stop();//调用Base.stop

            Console.WriteLine("Derive1转换成Base后调用成员”);

            Base b1 = d1;

           // b1.start();//非法调用

            b1.turn();//调用Derive1.trun

            b1.stop();//调用Base.stop

            Console.WriteLine("Derive1转换成IVehicle后调用成员");

            IVehicle v1 = d1;

            v1.start();//调用Base.start

            v1.turn();//调用Derive1.turn

            v1.stop();//调用Base.stop

 

            Derive2 d2 = new Derive2();

            Console.WriteLine("调用Derive2的成员");

            //d2.start();//非法调用

            d2.turn();//调用Base.turn

            d2.stop();//调用Derive2.stop

            Console.WriteLine("Derive2转换成Base后调用成员");

            Base b2 = d2;

            //b2.start();//非法调用

            b2.turn();//调用Base.turn

            b2.stop();//调用Base.stop

            Console.WriteLine("Derive2转换成IVehicle后调用成员");

            IVehicle v2 = d2;

            v2.start();//调用Derive2.start

            v2.turn();//调用Base.turn

        v2.stop();//调用Derive2.stop

运行结果

调用Derive1的成员

Derive1.turn

Base.stop

Derive1转换成Base后调用成员

Derive1.turn

Base.stop

Derive1转换成IVehicle后调用成员

Base.start

Derive1.turn

Base.stop

调用Derive2的成员

Base.turn

Derive2.stop

Derive2转换成Base后调用成员

Base.turn

Base.stop

Derive2转换成IVehicle后调用成员

Derive2.start

Base.turn

Derive2.stop

 

C#引入了太多复杂的技术，比如在接口的实现和继承方面。这些复杂性带来的好处远远小于他的坏处。程序员理解这些复杂的技术是很困难的，理解不彻底只会带来错误，聪明的程序员也许可以理解并很好的使用这些复杂的技术写出非常优美的代码，但这些代码公布出来后对于想使用这些代码却又不太聪明的程序员就是一种灾难，本来就复杂的技术，再加上聪明的程序员的摆弄就会更加晦涩难懂，一个软件开发队伍不能对要使用的技术和内容有一个一致的理解，软件的错误当然也就在所难免了。

更重要的，这些复杂的技术并非是必须的，同样的问题在没有这些技术时也可以得到解决，方法可能会丑陋一些，但只要解决好了后同样能高效的工作，能容易地被更多人理解，团队开发出的软件却能有更少的错误，更可靠。Java就没有这些复杂的东西，这么多年来依然应用的很好。Java的失误之处在于过于注重平台移植性，忽略了对使用最为广泛的Windows平台应加以宠幸，因此一直不是开发桌面应用首选。

 

还有一个复杂的地方，虚函数在构造函数中调用，C++构造函数中虚函数调用是按非虚函数调用进行的，但C#就要按虚函数进行调用，为此，对象的初始化步骤就复杂多了，如果在类成员定义时就对其赋值，该赋值将在基类的构造函数执行前进行，如果在构造函数中对其进行赋值，这样的赋值将在基类的构造函数执行之后进行。

到了代理部分，光弄清对象创建就足以让你的脑袋疼一天。

 

C#的函数调用在转变成机器码后，函数调用规则使用__fastcall调用规则

 

软件工程中的大部分ideas都是为了控制复杂性

结构化用粗粒度的划分解决复杂性；OO将状态与行为相联姻，用抽象的方法降低复杂性；组件的方法将程序分成各个部分，部分之间的连接是基于接口和协议，从而降低复杂性。组件编程建立了一个这样的世界，在这个世界里，使用高级语言将各个组件组装起来形成一个完整的应用，这样就可以不需要技术纯熟的程序员也能写出良好的应用。组件编程的前提是问题域可以分成离散的组件，组件之间只需要简单的方法访问就能相互协作。但事实上，软件的某些方面是渗透在整个软件中不能单独分离出来的，比如安全问题、线程管理、并发控制等等。这些问题可以用AOP的方法来解决