1.All Types Are Derived from System.Object
The CLR requires all objects to be created using the new operator（Employee e = new Employee("ConstructorParam1");）
the new operator does:
1.It calculates the number of bytes required
2.It allocates memory for the object,then all of these bytes are set to zero
3.initializes the object’s type object pointer and sync block index members
4.The type’s instance constructor is called
returns a reference (or pointer) to the newly created object.The CLR uses a garbage-collected environment that automatically detects the new operator
2.Casting Between Types
an object is type safety,because GetType() is nonvirtual.
it necessary to cast an object to various types. The CLR allows you to cast an object to its type or to any of its base types.
the proper way to declare the PromoteEmployee method would be to specify an Employee type instead of an Object type as its parameter so that the compiler produces a compiletime error
3.Casting with the C# is and as Operators
checks whether an object is compatible with a given type
operator is typically used,but the CLR is actually checking the object’s type twice and certainly comes at a performance cost
a way to simplify this code and improve its performance by providing an as operator.
CTE:compile-time error;RTE:run-time error
4.Namespaces and Assemblies
Namespaces:
1.the logical grouping of related types,(model中的的entity)
2.developers typically use them to make it easier to locate a particular type（逻辑处理）
the compiler needs to ensure：1.every type referenced exists；2.using type in the correct way:
When checking for a type’s definition, the compiler must be told which assemblies to examine by using the /reference compiler switch。The compiler will scan all of the referenced assemblies looking for the type’s definition.
After the compiler finds the proper assembly, the assembly information and the type information is emitted into the resulting managed module’s metadata.
two namesapce both hace a type called Widget(),they does something entirely different.
1.
2.
Be aware that a namespace and an assembly (the file that implements a type) aren’t necessarily related.
1.In particular, the various types belonging to a single namespace might be implemented in multiple assemblies.(the System.IO.FileStream type is implemented in the MSCorLib.dll assembly, and the System.IO.FileSystemWatcher type is implemented in the System.dll assembly.)
2.A single assembly can contain types in different namespaces. (the System.Int32 and System.Text.StringBuilder types are both in the MSCorLib.dll assembly.)
3.When you look up a type in the .NET Framework SDK documentation, the documentation will clearly indicate the namespace that the type belongs to and also the assembly that the type is implemented in.(ResXFileRef type is part of the System.Resources namespace and that the type is implemented in the System.Windows.Forms.dll assembly)
5.How Things Relate at Run Time
1.explain the relationship at run time between types, objects, a thread’s stack, and the managed heap
2.explain the difference between calling static methods, instance methods, and virtual methods
1.
2.As the just-in-time (JIT) compiler converts M3’s Intermediate Language (IL) code into native CPU instructions, it notices all of the types that are referred to inside M3: Employee, Int32, Manager, and String。
the CLR ensures that the assemblies that define these types are loaded. Then, using the assembly’s metadata, the CLR extracts information about these types and creates some data structures to represent the types themselves.
assume that the Int32 and String type objects have already been created
all objects on the heap contain two overhead members: the type object pointer and the sync block index.
the CLR has ensured that all of the type objects required by the method are created and the code for M3 has been compiled, the CLR allows the thread to execute M3’s native code.
3. prologue code executes, memory for the local variables must be allocated from the thread’s stack。
the CLR automatically initializes all local variables to null or 0 (zero) as part of the method’s prologue code
4.M3 executes its code:This causes an instance of the Manager type, a Manager object, to be created in the managed heap.The new operator returns the memory address of the Manager object, which is saved in the variable e (on the thread’s stack).
Whenever a new object is created on the heap, the CLR automatically initializes the internal type object pointer member to refer to the object’s corresponding type object.Furthermore, the CLR initializes the sync block index and sets all of the object’s instance fields to null or 0 (zero) prior to calling the type’s constructor, a method that will likely modify some of the instance data fields.
5.M3 calls Employee’s static Lookup method.returns the address of this object. The address is saved in the local variable e
When calling a static method,the JIT compiler locates the type object that corresponds to the type that defines the static method.Then, the JIT compiler locates the entry in the type object’s method table that refers to the method being called, JITs the method (if necessary), and calls the JITted code.
6.M3 calls Employee’s nonvirtual instance GetYearsEmployed method.The integer is saved in the local variable year
When calling a nonvirtual instance method, the JIT compiler locates the type object that corresponds to the type of the variable being used to make the call.
In this case, the variable e is defined as an Employee. (If the Employee type didn’t define the method being called, the JIT compiler walks down the class hierarchy toward Object looking for this method. It can do this because each type object has a field in it that refers to its base type; this information is not shown in the figures.)
Then,the JIT compiler locates the entry in the type object’s method table that refers to the method being called, JITs the method (if necessary), and then calls the JITted code.
7.M3 calls Employee’s virtual instance GetProgressReport method.Manager’s GetProgressReport implementation is called because e refers to a Manager object
When calling a virtual instance method, the JIT compiler produces some additional code in the method, which will be executed each time the method is invoked. This code will first look in the variable being used to make the call and then follow the address to the calling object.
the code will examine the object’s internal type object pointer member; this member refers to the actual type of the object. The code then locates the entry in the type object’s method table that refers to the method being called, JITs the method (if necessary), and calls the JITted code.
question:Employee and Manager type objects both contain type object pointer
members.
answer:type objects are actually objects themselves. When the CLR creates type
objects, the CLR must initialize these members.when the CLR starts running in a process, it immediately creates a special type object for the System.Type type
the System.Type type object is an object itself and therefore also has a type object pointer member in it, and it is logical to ask what this member refers to. It refers to itself because the System.Type type object is itself an “instance” of a type object.
System.Object’s GetType method simply returns the address stored in the specified object’s type object pointer member.
In other words, the GetType method returns a pointer to an object’s type object, and this is how you can determine the true type of any object in the system (including type objects).