[CLR via C#]8. 方法

internal struct Point{
    pblic Int32 m_x, m_y;
}
internal sealed class Rectangle {
    public Point m_topLeft, m_bottomRight;
}

internal struct Point {
    // 在C#中，向一个值类型应用关键字new,
    // 可以调用构造器来初始化值类型的字段。
    public Int32 m_x, m_y;
    public Point(Inte32 x, Int32 y) {
        m_x = x;
        m_y = y;
    }
} 
 
internal sealed class Rectangle {
    public Point m_topLeft, m_bottomRight;
    
    public Rectangle() {
        m_topLeft = new Point (1, 2);
        m_bottomRight = new Point (100, 200);
    }
}

internal struct Point {
    public Int32 m_x, m_y;
    public Point() {
        m_x =m_y = 5;
    }
} 
 
internal sealed class Rectangle {
    public Point m_topLeft, m_bottomRight;
    
    public Rectangle() {
 
    }
}

internal struct SomeValType {
    //不能再值类型中内联实例字段的初始化
    private Int32 m_x = 5;
}    

internal struct SomeValType {
    private Int32 m_x,m_y;
 
    //C#允许为值类型定义有参构造器
    public SomeValType(Int32 x){
        m_x = x;
    }
}

//C#允许为之类定义有参构造器
public SomeValType(Int32 x){
    //this代表本身实例，使用new操作符会将所有的字段初始化为0/null
    this = new SomeValType();
    //使用x覆盖m_x的0
    m_x = x;
    //现在y已经初始化为0了
}

internal sealed class SomeRefType {
    static SomeRefType () {
        //SomeRefType 被首次访问时，执行这里的代码。
    }
}
internal struct SomeValType {
    //C#允许值类型定义无参构造器
    static SomeValType () {
        //SomeValType 被首次访问时，执行这里的代码。
    }
}

internal sealed class SomeType{
    public static Int32 s_x = 5;
}

public sealed class TypeConstructorPerformance {
    public static void Go() {
        const Int32 iterations = 1000 * 1000 * 1000;
        PerfTest1(iterations);
        PerfTest2(iterations);
    }
 
    // 由于这个类没有显示定义类型构造器，所以C#在元数据中
    // 用BeforeFieldInit来标记类型定义
    internal sealed class BeforeFieldInit {
        public static Int32 s_x = 123;
    }
 
    // 由于这个类显示定义了类型构造器，所以C#在元数据中
    // 没有用BeforeFieldInit来标记类型定义
    internal sealed class Precise {
        public static Int32 s_x;
        static Precise() { s_x = 123; }
    }
 
    // 这个方法被JIT编译时, BeforeFieldInit 和Precise 类
    // 的类型构造器还没有被执行，所以这些构造器的调用将嵌入
    // 这个方法的代码中，使它允许较慢
    private static void PerfTest1(Int32 iterations) {
        Stopwatch sw = Stopwatch.StartNew();
        for (Int32 x = 0; x < iterations; x++) {
            // JIT编译器优化调用BeforeFieldInit 的
            // 类型构造器的代码，是他在循环开始之前执行
            BeforeFieldInit.s_x = 1;
        }
        Console.WriteLine("PerfTest1: {0} BeforeFieldInit", sw.Elapsed);
 
        sw = Stopwatch.StartNew();
        for (Int32 x = 0; x < iterations; x++) {
            // JIT编译器在这里生成调用Precise 类的类型构造器的代码
            // 所以每次循环迭代，它都要核实一遍是否需要调用构造器
            Precise.s_x = 1;
        }
        Console.WriteLine("PerfTest1: {0} Precise", sw.Elapsed);
    }
 
    // 这个方法被JIT编译时, BeforeFieldInit 和Precise 类的
    // 类型构造器已经执行过了。所以，在这个方法的代码中，不会
    // 在对这些构造器的调用，是它运行得更快
    private static void PerfTest2(Int32 iterations) {
        Stopwatch sw = Stopwatch.StartNew();
        for (Int32 x = 0; x < iterations; x++) {
            BeforeFieldInit.s_x = 1;
        }
        Console.WriteLine("PerfTest2: {0} BeforeFieldInit", sw.Elapsed);
 
        sw = Stopwatch.StartNew();
        for (Int32 x = 0; x < iterations; x++) {
            Precise.s_x = 1;
        }
        Console.WriteLine("PerfTest2: {0} Precise", sw.Elapsed);
    }
}