C# Programming Language

Types

类别	描述
值类型 value type	简单类型	int, byte, char, float, decimal, bool
	枚举类型	enum
	结构类型	struct
引用类型 reference type	类类型	object, string, 自定义 class
	接口类型	interface
	数组类型	int[]
	委托类型	delegate

Enum
- 简单的 type - Days of the Week, Payment Status
Struct
- 可以用于 Enum, can have constructors, properties, and methods, but cannot have an explicit parameterless constructor in C#

Delegate

type-safe function pointer
通过使用 +=, -=, invoke 会调用所有的 delegate functions

堆和栈

值类型的数据被保存在栈(stack)上，引用类型的数据被保存在堆(heap)上，当值类型作为参数传递给函数时，会将其复制到新的内存空间中，因此在函数中对该值类型的修改不会影响原始值类型

拆箱和装箱

装箱
- 将栈 (value type) 中的内容迁移到堆上 (reference type)
  - int double 转换为对应的引用(object)类型
拆箱
- 把引用转成值类型，把堆中的内容转移到栈上去

int i=3;
objcet o=i;//装箱
i=(int)o //拆箱

== 和 Equals 的区别

Equals 继承自 Object，一般用于比较对象内容是否相等
== 比较 type value 值是否相等，reference value 比较地址是否相等

内存泄漏

静态引用：如果一个静态对象长时间存活且占用大量内存，并且该对象不会被释放或重置，可能导致内存泄漏
不使用的引用对象没有置 null
委托或事件没有解除注册

Virtual & Abstract

相同点
- 抽象方法和虚方法都可以供派生类重写, 派生类重写父类的方法都要使用关键字 override 来声明。
不同点
- 虚方法必须有方法名称和方法实现；抽象方法是只有方法名称,没有方法实现；
- 虚方法在派生类中可以实现,也可以不实现；抽象方法是一种强制派生类覆盖的方法,子类必须实现,否则派生类将不能被实例化;
- 抽象方法只能在抽象类中声明,虚方法不是，如果类包含抽象方法,那么该类也必须声明为抽象类；
- 抽象方法使用修饰符 abstract 声明,虚方法使用方法修饰符 virtual 声明；

public abstract class AbstProgram            // 必须声明为抽象类
{
  public abstract string abstMethod();     // 抽象方法

  public virtual void virMethod()          // 虚方法
  {
    Console.WriteLine("hello, virmethod");
  }
}

public class Subclass: AbstProgram
{
  // 抽象方法必须实现
  public override string abstMethod()
  {
    return "hello,abstMethod";
  }

  // 虚方法可以实现,也可以选择不实现
  // public override void virMethod()
  // {
  //   Console.WriteLine("hello,virmethod");
  // }
}

Interface & abstract

相同点
- 都可以被继承
- 都不能直接被实例化
- 都可以包含方法声明且都没有实现
- 派生类必须实现未实现的成员
不同点
- 接口支持多实现，抽象类只能被单一继承实现；
- 接口中的成员访问类型默认为公共的，不能有其他的访问修饰符修饰；
- 定义的关键字不一样，抽象类需要 abstract，而接口则使用 interface；
- 接口可以作用于值类型(枚举可以实现接口)和引用类型，抽象类只能作用于引用类型；
- 接口不能包含字段和已实现的方法, 接口只包含方法、属性、索引器、事件的签名；抽象类可以定义字段、属性、包含有实现的方法；
- 在抽象类中, 新增一个方法的话, 继承类中可以不用作任何处理；而对于接口来说, 则需要修改继承类, 提供新定义的方法；
- 接口用于规范, 更强调契约, 抽象类用于共性, 强调父子。抽象类是一类事物的高度聚合, 那么对于继承抽象类的子类来说, 对于抽象类来说, 属于”Is A”的关系; 而接口是定义行为规范, 强调”Can Do”的关系, 因此对于实现接口的子类来说, 相对于接口来说, 是”行为需要按照接口来完成”；

public interface IMyInterface       // 接口
{
    public void intMethod();
}

public abstract class AbstProgram       // 抽象类
{
    public abstract void abstMethod();
}


public class SubClass: AbstProgram, IMyInterface
{
    public override void abstMethod()
    {
        Console.WriteLine("hello,abstMethod");
    }

    public void intMethod()
    {
        Console.WriteLine("hello,intMethod");
    }
}

Interface & Class

相同点
- 接口、类和结构体都可以从多个接口继承；
- 接口似于抽象基类, 继承接口的任何非抽象类型都必须实现接口的所有成员；
- 接口和类都可以包含事件、索引器、方法和属性；
不同点
- 不能直接实例化接口；
- 接口可以实现多继承，类只能被派生类单独继承；
- 接口只包含方法或属性的声明，不包含方法的实现，而类定义的方法必须实现；
- 表达的含义不同,接口定义了所有类继承接口时应遵循的”语法合同”；接口定义了语法合同 “是什么” 部分,派生类定义了语法合同 “怎么做” 部分；

interface IMyInterface
{
    void MethodToImplement();           // 接口成员
}

class InterfaceImplementer: IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    // 类实现接口
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

virtual、sealed、override 和 abstract 的区别

virtual 声明虚方法的关键字，说明该方法可以被重写。
sealed 说明该类不可被继承，也就是声明该类为密封类。
override 重写基类/父类的方法。
abstract 声明抽象类和抽象方法的关键字，抽象方法不提供实现，由子类实现，抽象类不可实例化。

public abstract class Program
{
    public abstract string abstmethod();     // abstract

    public virtual void virmethod()          // virtual
    {
        Console.WriteLine("hello,virmethod");
    }
}

public sealed class SubClass: Program      // sealed
{
    public override string abstmethod()      // override
    {
        return "hello,abstmethod";
    }
}

const 与 readonly 的区别

const 字段只能在该字段的声明中初始化；而 readonly 字段可以在声明或构造函数中初始化。因此，根据所使用的构造函数，readonly 字段可能具有不同的值。
const 字段是编译时常数，而 readonly 字段是运行时常数，是运行时确认的（一个在编译时就确定了，一个在运行时才确定）。
const 默认就是静态的，而 readonly 如果设置成静态的就必须显示声明。
const 对于引用类型的常数，可能的值只能是 string 和 null；而 readonly 可以是任何类型。

class Program
{
public static readonly int NumberA = NumberB \* 10;
public static readonly int NumberB = 10;

    public const int NumberC = NumberD * 10;
    public const int NumberD = 10;

    static void Main(string[] args)
    {
        Console.WriteLine("NumberA is {0}, NumberB is {1}.", NumberA, NumberB);     //NumberA is 0, NumberB is 10.
        Console.WriteLine("NumberC is {0}, NumberD is {1}.", NumberC, NumberD);     //NumberC is 100, NumberD is 10.
        Console.ReadLine();
    }
}

重载 (override) 和重写 (overload) 有什么区别

重载: 当类包含两个名称相同但签名不同(方法名相同,参数列表不相同)的方法时发生方法重载。用方法重载来提供在语义上完成相同而功能不同的方法。(一个类中、多个方法)
重写: 在类的继承中使用, 通过覆写子类方法可以改变父类虚方法的实现。(二个类以上)

public class Program
{
    // 重载(override)
    public void method(int num1)
    {
    }

    public void method(string str1)
    {
    }

    // 虚方法
    public virtual void virtmethod()
    {
        Console.WriteLine("hello,virtmethod");
    }
}

public class SubClass: Program
{
// 重写(overload)
public override void virtmethod()
    {
        Console.WriteLine("hello,overload");
    }
}

结构体和类的区别

结构体是值类型，类是引用类型。
结构体常用于数据存储，类多用于行为。
类支持继承，而结构体不支持继承。
类可以为抽象类，结构体不支持抽象模式。
结构体不支持无参构造函数，也不支持析构函数，并且不能有 Protected 修饰符。

// Books 结构体实现
struct Books
{
    public string title;
    public string author;
    public string subject;
    public int book_id;
};

ref 与 out 的区别

使用 ref 型参数时，传入的参数必须先被初始化；对 out 而言，必须在方法中对其完成初始化。
使用 ref 和 out 时，在方法的参数和执行方法时，都要加 ref 或 out 关键字，以满足匹配。
out 适合用在需要 retrun 多个返回值的地方，而 ref 则用在需要被调用的方法修改调用者的引用的时候。

class Program
{
    public void test1(ref int i)
    {
        i = 99;
    }

    public void test2(out int i)
    {
        i = 11;
    }

    static void Main(string[] args)
    {
        Program p = new Program();

        int i = 1;
        p.test1(ref i);     // i = 99

        int j;
        p.test2(out j);     // j = 10
    }
}

值类型和引用类型的区别

值类型: 就是一个包含实际数据的对象。即当定义一个值类型的变量时，C#会根据它所声明的类型，以栈方式分配一块大小相适应的存储区域给这个变量，随后对这个变量的读或写操作就直接在这块内存区域进行；
引用类型: 一个引用类型的变量不存储它们所代表的实际数据，而是存储实际数据的引用。引用类型分两步创建：首先在栈上创建一个引用变量，然后在堆上创建对象本身，再把这个内存的句柄（也是内存的首地址）赋给引用变量；

//引用类型（由于使用了'Class'）
class SomeRef { public Int32 x; }

//值类型（由于使用了'Struct'）
struct SomeVal { public Int32 x; }

class Program
{
    static void ValueTypeDemo()
    {
        SomeRef r1 = new SomeRef();
        SomeVal v1 = new SomeVal();
        r1.x = 5;
        v1.x = 5;
        Console.WriteLine(r1.x); //显示"5"
        Console.WriteLine(v1.x); //同样显示"5"

        SomeRef r2 = r1;
        SomeVal v2 = v1;
        r1.x = 8;
        v1.x = 9;

        Console.WriteLine(r1.x);    //显示"8"
        Console.WriteLine(r2.x);    //显示"8"
        Console.WriteLine(v1.x);    //显示"9"
        Console.WriteLine(v2.x);    //显示"5"
    }
}

拆箱和装箱的定义及拆箱和装箱的性能影响？怎么解决?

装箱: 值类型转换为引用类型;
拆箱：引用类型转换为值类型；
影响: 都涉及到内存的分配和对象的创建，有较大的性能影响；
解决：使用泛型;

public class Solution
{
    static void Main(string[] args)
    {
        int i = 123; //声明一个 int 类型的变量 i，并初始化为 123
        object obj = i; //执行装箱操作
        Console.WriteLine("装箱操作：值为{0}，装箱之后对象为{1}", i, obj);
        int j = (int)obj; //执行拆箱操作
        Console.WriteLine("拆箱操作：装箱对象为{0}，值为{1}", obj, j);
    }
}

委托是什么？事件是不是委托？

c# 中的委托（Delegate）类似于 c 或 c++ 中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

事件是特殊的委托，事件内部是基于委托来实现的。

delegate int NumberChanger(int n);
class TestDelegate
{
    static int num = 10;
    public static int AddNum(int p)
    {
        num += p;
        return num;
    }

    public static int MultNum(int q)
    {
        num *= q;
        return num;
    }
    public static int GetNum()
    {
        return num;
    }

    static void Main(string[] args)
    {
        // 创建委托实例
        NumberChanger nc1 = new NumberChanger(AddNum);
        NumberChanger nc2 = new NumberChanger(MultNum);
        // 使用委托对象调用方法
        nc1(25);
        Console.WriteLine("Value of Num: {0}", GetNum());   // Value of Num: 35
        nc2(5);
        Console.WriteLine("Value of Num: {0}", GetNum());   // Value of Num: 175
        Console.ReadKey();
    }
}

构造函数 Constructor 是否可以被继承？是否可以被 Override 重载？

Constructor 不可以被继承，因此不能被重写（Overriding），但可以被重载(Overloading)。

public class Student
{
    public int Age { get; }
    public string Name { get; }

    public Student()
    {
        Console.WriteLine("对象被创建。");
    }

    public Student(string name) : this()
    {
        this.Name = name;
    }

    public Student(string name, int age) : this(name)
    {
        this.Age = age;
    }
}

public class Program
{
    static void Main(string[] args)
    {
        Student student_1 = new Student();
        Student student_2 = new Student("姓名", 14);
        Console.WriteLine(student_2.Name + ' ' + student_2.Age);
    }
}

String 类是否可以被继承？

String 类是 sealed 类故不可以继承。
当对一个类应用 sealed 修饰符时，此修饰符会阻止其他类从该类继承。在下面的示例中，类 SealedProgram 从类 DemoProgram 继承，但是任何类都不能从类 SealedProgram 继承。

class DemoProgram { };
sealed class SealedProgram: DemoProgram { };

Task 和 Thread 的区别

Task 比较新，发布于.NET 4.5 版本，而 Thread 在.NET 1.1 版本。
Task 能结合新的 async/await 代码模型写代码, 而 Thread 则不支持。
Task 可以创建线程池，返回主线程，管理 api，而 Thread 则不能。
Task 是多核多线程，Thread 是单核多线程。

public class Solution
{
  static void Main()
  {
    var testTask = new Task(() =>
    {
      Console.WriteLine("hello, Task");
    });

    Console.WriteLine(testTask.Status); // Created
    testTask.Start();
  }
}

public class Solution
{
    static void Main(string[] args)
    {
        ThreadTest test = new ThreadTest(); //创建 ThreadTest 类的一个实例
        Thread thread = new Thread(new ThreadStart(test.MyThread)); //调用 test 实例的 MyThread 方法
        thread.Start(); //启动线程
        Console.ReadKey();
    }
}

public class ThreadTest
{
    public void MyThread()
    {
      Console.WriteLine("这是一个实例方法");
    }
}

其他

死锁的必要条件？怎么克服?

死锁的原因主要是:
- 因为系统资源不足。
- 进程运行推进的顺序不合适。
- 资源分配不当等。如果系统资源充足,进程的资源请求都能够得到满足,死锁出现的可能性就很低,否则就会因争夺有限的资源而陷入死锁。其次,进程运行推进顺序与速度不同,也可能产生死锁。
必要条件
- 互斥条件：一个资源每次只能被一个进程使用。
- 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
处理死锁的措施
- 预防死锁：通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个条件，来防止死锁的发生。
- 避免死锁：在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免死锁的发生。
- 检测死锁：允许系统在运行过程中发生死锁，但可设置检测机构及时检测死锁的发生，并采取适当措施加以清除。
- 解除死锁：当检测出死锁后，便采取适当措施将进程从死锁状态中解脱出来。

Error 和 Exception 有什么区别？

Error 是不可捕捉到的，无法采取任何恢复的操作。Except 表示可恢复的例外，这是可捕捉到的。举个例子：跟儿子逛街，儿子看中一个奥特曼是 Exception，没带钱是 Error。
Error 更多的表示系统方面的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢出，内存溢出等；而 Exception 类表示程序可以捕获到的异常（比方说 c#的 try-catch 语句），可以捕获且可能恢复，出现这类异常，应该及时处理，使得程序正常运行，从而避免影响整个项目的运行。

UDP 和 TCP 连接有什么区别?

TCP 是传输控制协议，提供的是面向连接的，是可靠的，字节流服务，TCP 提供超时重拨，检验数据功能。
UDP 是用户数据报协议，是一个简单的面向数据报的传输协议，是不可靠的连接。
TCP 保证数据正确性，UDP 可能丢包，TCP 保证数据顺序，UDP 不保证。
TCP 对系统资源的要求较多, UDP 较少。

Are you ready?

C#