C#面试笔试小贴士 2

对于多态，还必需提一个C#中的关键字：new。前面提到，对于virtual方法，JIT会确定实例的实际类型然后决定调用什么方法。但是如果派生类中new关键字修饰方法，则它向CLR澄清此派生类中的方法与基类中的方法毫无关系，以下代码最终调用是基类的introduce方法：

Code
class Program
{
    static void Main(string[] args)
     {
         Sample1.M1(new OrdinaryPeople("ZhangSan"));
         Sample1.M1(new Superman("Hancock"));
         Console.Read();
     }
}

class Sample1
{
    public static void M1(Person p)
     {
         p.Introdce();
     }
}

class Person
{
    protected string mName;
    public Person(string pName)
     {
        this.mName = pName;
     }

    public virtual void Introdce()
     {
         Console.WriteLine("Hello,I am " + this.mName);
     }
}

class OrdinaryPeople : Person
{
    public OrdinaryPeople(string pName)
         : base(pName)
     {
     }

    public new void Introdce()
     {
         Console.WriteLine("Hello,I am an ordinary person," + this.mName);
     }
}

class Superman : Person
{
    public Superman(string pName)
         : base(pName)
     {
     }

    public new void Introdce()
     {
         Console.WriteLine("Hi,I am a Superman," + this.mName);
     }
}

ü   操作符重载
对于操作符重载我认为掌握基本的语法即可（况且它们不属于CLS）。以下是Grant Palmer的《C#程序员参考手册上的例子》，实际上演示了复数的加法运算，输出 5-3i：

Code
class Program
{
    static void Main(string[] args)
     {
         Complex a = new Complex(3, 4);
         Complex b = new Complex(2, -7);
         Complex c = a + b;
         Console.WriteLine(c);
         Console.Read();
     }
}

public class Complex
{
    double a, b;
    public Complex(double d1, double d2)
     {
        this.a = d1;
        this.b = d2;
     }

    public static Complex operator +(Complex c1, Complex c2)
     {
         Complex c3 = new Complex(c1.a + c2.a, c1.b + c2.b);
        return c3;
     }

    public override string ToString()
     {
        if (b < 0)
         {
            return a.ToString() + "-" + Math.Abs(b) + "i";
         }
        else
         {
            return a.ToString() + "+" + b + "i";
         }
     }
}

 

ü   不安全代码
不安全代码指（显式）使用了指针的代码。注意两个关键字：unsafe、fixed。Unsafe适用于类、结构体、方法、字段、类或结构体的某一代码块。
由于C#中引用类型的对象位于堆上，而堆是由垃圾回收器管理，为避免内存碎片，有时候垃圾回收器需要移动这些对象，如果你显式使用指针访问这些内容，这样就很容易造成无效指针，这时就需要使用fixed关键字，指明保持此对象在堆上的地址是固定的。以下示例中M1方法使用了fixed，因为数组为引用类型（如果不使用，将出现编译错误“只能获取 fixed 语句初始值设定项内的未固定表达式的地址”），而M2方法则无需使用fixed。

Code
class Program

{
    static void Main(string[] args)
     {
        int[] ar = new int[5] { 1,2,3,4,5};
         M1(ar);
         M2(ar[0]);
         Console.Read();
     }

    unsafe static void M1(int[] ar)
     {
        fixed (int* x = &ar[0])
         {
            for (int i = 0; i < ar.Length; i++)
             {
                 Console.WriteLine(*(x + i));
             }
         }
     }

    unsafe static void M2(int x)
     {
        int* i = &x;
         Console.WriteLine(*i);
     }
}

 

ü   访问修饰符
1）对于普通的类来说，仅可以使用public或internal（类的默认访问修饰符）访问修饰符，嵌套类可以使用public、internal、protected、private、protected interanl。
2）成员字段的访问修饰符包括：public、internal、protected、protected internal、private（默认访问修饰符）。其中internal指该成员字段可以被相同程序集中的类访问，internal指该成员字段可以被其派生类访问。Protected internal指protected or internal。

 

 

ü   单例模式
单例模式是最简单的一种设计模式，不过在写法上还是有一些细节值得注意的，下面是两个例子：

Code
public sealed class Singleton
{
    private static Singleton mIns;
    private static object mLock = new object();
    private Singleton()
     {
     }

    public static Singleton GegInstance()
     {
        lock (mLock)
         {
            if (mIns == null)
             {
                 mIns = new Singleton();
             }
            return mIns;
         }
     }
}

//
public sealed class Singleton
{
    public static readonly Singleton mIns = new Singleton();
}

 

ü   线程安全
关于线程安全的概念，以ATM机的取款程序来说，假设“用户存款”类中有一个“取款”的方法分为三步：（1）判断余额、（2）调用硬件接口出钞、（3）修改余额。显而易见，在系统对CPU时间片的调度中，中断可能发生在各步骤之间，那么当多线程操作时，很可能造成最终余额不正确。
对于.NET类库中的类与用户定义的类来说，绝大多数的操作与上述的“取款”一样，不是原子操作，因而很可能造成对象最终处于一个不确定的状态。MSDN中对于每一个类，都附带说明其线程安全的的情况（当然，大多数在多线程写的情况下都是不安全的，包括我们常用的集合类、UI控件类等等）。对于这些非线程安全的类来说，只能通过用户在编码的过程中通过同步的机制来确保代码的线程安全。