类型基础---CLR Via C#笔记一

 

---

一.所有类型都是从System.Obejct派生

1.下面两个类型定义是完全一致的:

class Employee{
    ...
}
class Employee:System.Object{
    ...
}

 

2.System.Object的公共实例方法

　　a.Equals 判断对象是否具有相等的值

　　b.GetHashCode 返回对象值的哈希码

　　c.ToString 该方法默认返回类型的完整名称( this.GetType().FullName )

　　d.GetType 返回从Type派生的一个对象的实例,指出调用GetType的那个对象是什么类型

 

3.System.Object的受保护方法

　　a.MemberwiseClone 这个非虚方法能创建类型的新实例,并将新对象的实例字段设与this对象的实例字段完全一致.返回的是一个对新实例的引用( 这是译文,说实话,没看懂,然后查阅了MSDN,其实这个方法的功能是创建一个浅表副本,是创建一个新对象,然后将当前对象的非静态字段复制到这个浅表副本中,即新对象中.如果字段是值类型,则执行逐位复制.如果是引用类型,则复制引用而不复制引用对象,因此,原始对象及其副本引用同一对象 )

　　以下是浅表复制和深入复制操作的区别

    public class IdInfo
    {
        public int IdNumber;

        public IdInfo(int IdNumber)
        {
            this.IdNumber = IdNumber;
        }
    }

    public class Person
    {
        public int Age;
        public string Name;
        public IdInfo IdInfo;

        //浅表复制
        public Person ShallowCopy()
        {
            return (Person)this.MemberwiseClone();
        }

        //深入复制
        public Person DeepCopy()
        {
            Person other = (Person)this.MemberwiseClone();
            other.IdInfo = new IdInfo(this.IdInfo.IdNumber);
            return other;
        }
    }

    class Program
    {
        public static void DisplayValues(Person p)
        {
            Console.WriteLine("Name:{0:s} , Age:{1:d}",p.Name,p.Age);
            Console.WriteLine("Value:{0:d}",p.IdInfo.IdNumber);
        }

        static void Main(string[] args)
        {
            //创建一个Person对象
            Person p1 = new Person();
            p1.Age = 42;
            p1.Name = "Sam";
            p1.IdInfo = new IdInfo(5042);

            //复制p1给p2
            Person p2 = (Person)p1.ShallowCopy();

            //展示这些值
            Console.WriteLine("p1实例的值");
            DisplayValues(p1);
            Console.WriteLine("p2实例的值");
            DisplayValues(p2);

            Console.WriteLine("===========改变p1值的属性并展示p1和p2的值的时候===========");

            //改变p1值的属性并展示p1和p2的值的时候
            p1.Age = 32;
            p1.Name = "Frank";
            p1.IdInfo.IdNumber =7080;
            Console.WriteLine("p1实例的值");
            DisplayValues(p1);
            Console.WriteLine("p2实例的值");
            DisplayValues(p2);

            //从结果可以看出,浅表复制由于引用类型复制了对象的引用,当该浅表中所对应原本对象的引用值发生改变时,则浅表中引用类型值
            //也会发生改变,而原对象的值类型发生改变时,浅表中值类型的值却不会改变

            Console.WriteLine("===========创建一个深入复制的对象给p3===========");

            //创建一个深入复制的对象给p3
            Person p3 = p1.DeepCopy();
            p1.Name = "Gergoe";
            p1.Age = 22;
            p1.IdInfo.IdNumber = 6660;
            Console.WriteLine("p1实例的值");
            DisplayValues(p1);
            Console.WriteLine("p3实例的值");
            DisplayValues(p3);

            //从结果可以看出,深入复制是把原对象的引用类型也进行了复制,也就是说,把原对象的引用类型字段重新new了...!

            Console.ReadLine();

            //以上代码结果:
            //p1实例的值
            //Name:Sam , Age:42
            //Value:5042
            //p2实例的值
            //Name:Sam , Age:42
            //Value:5042
            //===========改变p1值的属性并展示p1和p2的值的时候===========
            //p1实例的值
            //Name:Frank , Age:32
            //Value:7080
            //p2实例的值
            //Name:Sam , Age:42
            //Value:7080
            //===========创建一个深入复制的对象给p3===========
            //p1实例的值
            //Name:Gergoe , Age:22
            //Value:6660
            //p3实例的值
            //Name:Frank , Age:32
            //Value:7080
        }
    }

　　b.Finalize 在垃圾回收器判断对象是否被作为垃圾回收之后,在该对象的实际地址被回收之前,会调用这个虚方法

 

 4.CLR要求new创建对象　

Employee employee = new Employee("ConstructorParam1");

然而,new需要做的工作是:

　　a.它计算类型及其所有基类型( 一直到System.Object )中定义字段所需的字节数.堆上每个成员都需要一些overhead成员,即开销成员——"类型对象指针"( type object pointer )和"同步块索引"( sync block index ).这些成员由CLR共同管理对象.这些额外成员的字节数会计入对象大小.

　　b.它从托管中分配指定类型要求的字节数,从而分配对象的内存,分配所有字节都设为零.

　　c.初始化"类型对象指针"和"同步化索引块"

　　d.调用类型的实例构造器.

注:引用类型有除了实例字段开销之外,还包括两个字段的开销,即"同步化索引块"和"类型对象指针".

 

 5.类型转换 ( 看父不看子 )

　　CLR最重要的特性就是类型安全性.在运行时,CLR总是知道一个对象是什么类型.调用GetType方法,总是知道一个对象确切的类型是什么.由于这个方法是非虚方法(不能重写覆盖),所以一个类型不能伪装成另一个类型.这句话很好理解,一个Employee类不能重写GetType方法,所以不能返回一个其他类型,比如SuperHero类型.

　　C#不要求任何特殊语法即可将一个对象转化为它的任何基类型,因为基类型转换被认为是一种安全的隐式转换.然而,将对象转化为它的某个派生类型时,C#要求只能进行显式转换,因为这样的转换可能在运行时失败.

　　注:声明方法参数类型的最好方法是将参数类型指定,而不是Object,这避免了运行时错误,将错误提早到编译时.

 

6.使用C#的 is 和 as 操作符来转型

　　使用 is 检查一个对象是否兼容于指定的类型,并返回一个 boolean 值: true 或 false . ( is 永远也不会抛出异常 ).

　　如果对象的引用是 null , is 操作符总是返回 false ,因为没有可供检查的对象.

　　is 操作符的使用:

if( o is Employee )
{
    Employee e = (Employee) o;
    ...
}

　　在上面这段代码中,CLR实际上会检查两次对象的类型. is 操作符首先核实 o 是否兼容于 Employee 类型. 如果是,那么在 if 语句内部执行转型时,CLR再次核实 o 是否引用一个Employee.这无疑造成了性能的损失.

　　因为CLR必须判断 变量o 引用的实际类型,然后CLR必须遍历继承层次结构,用 o 的每个基类型去核对每个指定的类型 Employee.

　　所以,C#提供了另一个操作符 as ,目的是简化这段代码操作 ,并提升其性能 .

Employee e = o as Employee;
if( null != e )
{
    ...
}

　　在这段代码中,CLR核实 o 是否兼容 Employee 类型 ;如果是,则 as 会返回对同一个对象的非 null 引用.如果 o 不兼容 Employee 类型, as 操作符会返回 null .

　　检查是否为 null 比校验一个对象的类型要效率的多.

　　同样, as 操作符也不会抛出异常.

　　

7.命名空间和程序集

　　命名空间用于逻辑性分组;

　　　　CLR不知道命名空间的任何事,访问一个类型时,CLR需要知道类型的完整名称以及该类型具体定义在哪个程序集中.

　　创建命名空间别名:

using Microsoft;            //尝试添加"Microsoft."前缀
using Wintellect;            //尝试添加"Wintellect."前缀

//将WintellectWidget符号定义成Wintellect.Widget的别名
using WintellectWidget = Wintellect.Widget;

public sealed class Program
{
    public static void main()
    {
        //使用别名创建对象
        WintellectWidget w = new WintellectWidget();
    }
}

namespace CompanyName
{
    public sealed class A {                        //TypeOf : Company.A
        ...
    }

    namespace X{
        public sealed class B { ... }            //TypeOf : CompanyName.X.B
    }
}