C#笔记

.Net

C#本质论(第四版)

挑选了一些看书是看起来比较有意思的东西记录一下. 重新看发现自己的笔记有点乱, 没头没尾的. 但是, 不得不说这真是本好书. 很好看懂.
看这本书,不求都懂, 对C#教之前能有一个大局观上的认识提升.
书看起来挺厚, 但是通俗易懂.
适合作为入门书籍
不适合作为工具书

第一章 概述

• C#编译器允许为C#源代码使用任何文件扩展名, 但一般为.cs
• C#中类名和文件名不一定一致, 但一般遵守这一约定
• Main方法返回类型必须为void或int, 而且要么不带参数, 要么带一个字符串数组(string[] args)
• [规范]C#标识符命名方式一般使用Pascal大小写风格
• [规范]局部变量一般使用camel 风格大小写(驼峰命名法)
• string不可变: 不能修改变量最初引用的数据, 只能重新赋值
• [规范]不要使用注释，除非代码本身＂一言难尽＂，　要尽量编写清晰的代码而不是通过注释澄清
• CIL: 公共中间语言(Common Intermediate Language)
• JIT: 即时编译(just-in-time compilatiion)
• CLS: 公共语言规范(Common Language Specification)
• CLI: 公共语言基础结构规范(Common Language Infrastructure)
• BCL: 基类库(Base Class Library)

第二章 数据类型

• decimal类型: 存储大数字(浮点), 能够准确其范围内的 数字表示而没有舍入误差
• 将字面值定义为decimal: 数值后面加m或M
• 将数值格式化为十六进制: System.Console.WriteLine("0x{0:X}",42)
• 在字符串前面使用@符号, 致命转移序列不被处理, 直接原样输出
• 属性: 具有getter方法和setter方法的特殊方法
• string是不可变的, 对String的修改会返回一个新的字符串, 而原字符串保持不变
• null只能赋值给引用类型,指针类型,可空类型
• 使用TryParse不容易引发异常: double.TryParse(input, out output)
• 利用default关键字可以获取数据类型的默认值: int count = default(int);

第三章 操作符和控制流

• [规范]使用复合格式化而不是 + 来拼接字符串 : string.Format()

第四章 方法和调用

• 形参: 方法声明的参数, 实参: 方法调用时传递的参数
• 用方法进行重构: 将一组语句相关语句转移到一个方法中, 而不是把他们留在一个较大的方法中, 尤其是那些不好理解的代码块, 用有意义的方法名清晰地定义代码的行为,与简单的为代码块添加一个注释效果要好得多
• [规范]形参列表使用 camel命名规范
• [规范]一个方法中尽可能确定单一退出位置
• using不会导入 任何嵌套命名空间中的类型. 必须现实导入
• using不允许使用通配符. 所有命名空间必须显示引入

• 参数默认是值传递的, 也就是说参数会复制一份到方法中而原来的值不会改变

  • 引用参数ref: 调用者应该对参数进行初始化
  • 输出参数out: 调用者不需要初始化, 方法体内对参数赋值后输出给调用者
    二者在实现功能上完全一致

• 参数数组: 声明param关键字. 参数数组不一定是方法中唯一的参数, 但一定要是最后一个, 每个方法最多只有一个参数数组

  例:将传入的参数构造成合法路径格式

static string Combine(params string[] paths)
{
    string result = string.Empty;
    foreach(string path in paths)
    {
        result = System.IO.Path.Combine(result,path);
    }
}

• 命名参数

static void Main()
{
    DisplayGreeting(firstName:"Inigo", lastName:"Montoya");
}
public void DispaltGreeting(
    string firstName, 
    string middleName = default(string),
    string lastName = default(string))
{
    //............        
}
//便利: 如果一个方法许多参数都有默认值, 这种做法极大方便编程
//代价: 牺牲接口灵活性: 方法参数名改变会带来编译错误

• 异常捕捉: 避免使用常规catch块, 而应该用catch(Exception ex)代替
  

  常规catch : try{}catch{}

第五章 类

• 对类实例化(new): "运行时"为类分配内存,实例化对象, 并返回对实例的引用
• 实例字段: 在类的级别上声明的变量, 用于存储与对象关联的数据
• 自动实现属性: public string Name{get;set;};
• 不使用自动实现的属性的属性和字段

class User
{
    //字段
    private string _Name;
    //属性
    public string Name
    {
        get{return _Name;}
        set{_Name = value;}
    }
    //自动实现的属性
    public string age{get;set;}
}
//调用
Class Program
{
    static void main()
    {
        User user = new User();
        User.Name = "Zhangsan";
        Console.WriteLine(User.Name);
    }
}
/**规范
    考虑为支持字段和属性使用相同的大小写风格
    考虑属性和它的类型通明
    避免使用camel风格命名字段
    不要声明public或者protected的字段, 而应该声明private然后通过属性公开
    有限使用自动实现的属性而不是字段
    如果没有额外的实现逻辑, 要优先使用自动实现的属性而不是编写属性的完整版本
**/

• 构造器: 即构造方法, 没有返回类型 && 方法名与类名相同

  new操作符的实现细节

  1. new操作符从内存管理器中获取"空白"内存,
  2. 调用指定的构造器, 对"空白"内存的引用作为隐式的this参数传给构造器
  3. 构造器链的剩余部分开始执行, 在构造器之间传递引用,这些构造器都没有返回类型
  4. 构造器链上的执行结束后, new操作符返回内存引用. 现在, 该引用指向内存处于初始化好的形式

• 静态构造器: 首次访问类是自动调用, 不能显示调用, 不允许任何参数

class Employee
{
    static Employee()
    {   
        Random randomGenerator = new Random();
        NextId = randomGenerator.Next(101,999);
    }
    public static int NextId = 42;
    //执行结果: 先执行声明语句:NextId = 42, 随后访问构造器: NextId 等于一个随机值
    //另外: 普通的构造器(实例构造器)执行的结果也是这样
}

• const字段: 自动成为静态字段, 不能带static修饰符, 不能改变
• readonly字段: 只能从构造器中修改或者在声明时指定. 其他情况只读
• 分部类

//File: a.cs
partial class Program
{
}
//File: b.cs
partial class Program
{
}

第六章 继承

• 隐式转型和显式转型

public class program
{
    public static void Main()
    {
        //假设Contact是PdaItem的子类
        Contact contact = new Contact();
        //隐式转型
        PdaItem item = contact;
        //显示转型,而且显示类型是必须的
        contact = (Contact)item;
    }
}

• 非嵌套派生类不能访问基类的私有成员
• 密封类: sealed修饰. 不允许被派生
• 重写属性需要1. 父类添加virtual关键字, 子类添加override关键字. 不允许重写字段或任何静态方法

public class PdaItem
{   
//不添加 virtual 关键字会报错
    public virtual string Name{get;set;}
}
public class Contact:PdaItem
{
//不添加override关键字会报严重警告
    public override string Name
    {
        get{ return FirstName + " " + LastName; }
        set
        {  
            string[] names = value.Split(' ');
            FirstName = names[0];
            LastName = names[1];
        }
    }
    public string FirstName{get;set;}
    public string LastName{get;set;}
}
//"运行时"遇到虚方法时, 会调用虚成员派生的最远的重写即 item.Name = "..."会执行Contact类中的方法--->虚方法不应该包含关键代码

• is操作符 : 验证基础类型
• as操作符 : 类型转换(如果转型失败会返回null)

第七章 接口

• 接口: 不包含实现, 也不包含数据
• 接口所有的成员自动定义为public, 程序员不允许使用访问修饰符
• [规范]接口的命名一I开头, 并使用Pascal大小写风格
• 声明显式接口要在成员名之前附加接口名前缀

第八章 值类型

• 值类型: 直接包含值.也就是说变量引用的位置就是值在内存中实际存在的位置
• 将一个原始变量赋值给另一个变量, 会在新变量的位置创建原始变量的一个内存副本
• 类似地, 将值类型的实例传给Console.WriteLine()这样的方法, 也会生成一个内存副本
• [规范] 不要创建大于16字节的值类型
• 除了String和object, C#所有"内建类型"都是值类型
• [规范] 要创建不可变的值类型

struct Angle
    {
        public int Degress { get;}
        public int Minutes { get; }
        public int Seconds { get; }
        //结构体只能声明有参构造器, 不能定义无参构造器
        public Angle(int degress, int minutes, int seconds)
        {
            Degress = degress;
            Minutes = minutes;
            Seconds = seconds;
        }
        //返回一个新的值类型
        public Angle Move(int degress, int minutes, int seconds)
        {
            return new Angle(
                Degress + degress,
                Minutes + minutes,
                Seconds + seconds);
        }
    }

• 装箱: 将值类型转换成引用类型
  

  装箱过程:
  

  1. 在堆上分配内存,用于存放值类型的数据以及少许的额外开销
  2. 发生一次内存复制, 将当前存储位置的值类型数据赋值到堆上
  3. 对堆上存储位置进行引用

• 频繁装箱拆箱会大幅影响性能

class DisplayFibonaci
{
    static void Mian()
    {
        int totalCount;
        System.Collection.ArrayList list = new System.Collection.ArrayList();
        Console.Write("Enter a numner between 2 and 1000:");
        totalCount = int.Parse(Console.ReadLine());
        list.Add((double)0);//装箱, Add方法的参数是object
        list.Add((double)1);//装箱
        for(int count = 2; count < totalCount; count ++)
        {
            //拆箱(两次): 加法运算需要值类型
            //装箱: Add方法参数类型为引用类型
            list.Add(((double)list[count-1] + (double)list[count-2]));
        }
        //拆箱: list内容为object, 赋值给double类型的count需要拆箱
        foreach(double count  in list)
        {
            //装箱: Console.Write(string format, object args)
            Console.Write("{0}\t",count);
        }
    }
}

• 不允许在lock语句中使用值类型
• 枚举: 实际是作为整数常量实现, 默认基础类型是int, 默认第一个枚举是0, 递增. 但是可以显示修改

enum ConnectionSate : short//修改默认基础类型
{
    DisConnected,       //0
    Connecting = 10,    //10  --- 修改默认值
    Connected,          //11
    Joined = conected,  //11
    Disconnecting       //12
}

• 允许添加枚举, 但是会使其后的枚举值发生顺移

第九章 良构类型

• 重写object的成员: 比如ToString();

public struct Coordinate
{
    public Coordinate(Longitude longitude, Latitude latitude)
    {
        _Longitude = longitude;
        _Latitude = latitude;
    }
    public Longitude Longitude{get{return _Longitude;}}
    privete readonly Longitude _Longitude;
    public Latitude Latitude{get{return _Latitude;}}
    privete readonly Latitude _Latitude;
    //重写ToString方法
    public override string Tostring()
    {
        return string.Formate("{0} {1}",Longitude, Latitude);
    }
}

• Console.WriteLine() 和 System.Diagnostics.Trace.Write()等方法会调用对象的Tostring()方法
• Equals: 引用值/值相等
• ReferenceEquals(): 同一引用
• 操作符重载格式: public static [DataType] operator [Ppertor]

public static bool operator ==(){...}
public static object operator + (){...}
 例: 检查坐标是否相等
 public static bool operator ==(Coordinate leftHandSide, Coordinate rightHandSide)
 {
    //Check if leftHandSide is also null
    //operator == would be recursive--使用 == 来检查null会造成死递归
    if(ReferenceEquals(leftHandSide,null))
    {
        return ReferenceEquals(rightHandSide,null);
    }
    return leftHandSide.Equals(rightHandSide));
 }

• 重载ture和false: 要求必须同时进行重载

public staic bool operator true(IsValid item){...}
public tatic bool operator false(IsValid item){...}

• 重载转型操作符

//在Latitute和double之间提供隐式转换
public struct Latitude
{
//------转换准备
    privete readonly double _DecimalDegress;
    public Latitude(double  dicimalDegress)
    {
        _DecimalDegress = Normalizi(decimalDegress);
    }
    public double DecimalDegress
    {
        get{return _DecimalDegress;}
    }
//-------转换
    public static implicit operator double(Latitude latitude)
    {
        return latitude.DecimalDegress;
    }
    public static implicit operator Latitude(double degress)
    {
        return new Latitude(degress);
    }
}
//

• 在命令行引用程序集

win: csc.exe /r:cooridnates.dll Program.cs
mono: msc.exe /r:cooridnates.dll Program.cs
* 

• 生成文档注释命令

/doc:sss.xml sss.cs    --- /doc:目标文件名  原文件名

• 垃圾回收是"运行时"的核心功能: 作用是回收不再被引用的对象所占用的内存
• 垃圾回收只清理内存, 不负责清理资源(文件句柄, 数据库链接字符串, 端口, 等)

//利用终结器清理资源:语法 ~类名
class FileHelper
{
    //构造器
    public FileHelper(){...}
    //终结器:--不能带参数 终结器不能显示调用, 由运行时在恰当的时间运行
    //对象最后一次使用之后并在程序正常关闭之前
    ~FileHelper(){....}
}

• 使用using执行确定终结

第十章 异常处理

第十一章 泛型

• 声明泛型

//接口
interface A<T>
//类
class B<T>
calss C<T> : A<T>
//接口约束
//---------规定I必须实现IComparable接口
class BinaryTree<T> where T: System.IComparable<T>
//---规定value必须为自定义实体类型
class myDic<TKty,TValue> where TValue : myEntity

• 约束的限制

  • 不支持操作符约束
  • 不支持or条件
  • 委托和枚举类型约束是无效的
  • 构造器约束值针对默认构造器

• 泛型方法public static T Max<T> (T first, params T[] values)

• 只有泛型接口和泛型委托可以是协变的, 泛型类和泛型结构永远不是协变的
• 使用out实现协变, 使用in实现逆变

第十二章 委托和lambda表达式

• 使用委托的冒泡排序

  using System;
  namespace Console_Test
  {
  //声明委托
  public delegate bool ComparisonHander(int first, int second);
  class Program
  {
      //声明一个方法
      //针对不同的排序方式可以声明多个不同的方法分别调用, 只要符合委托格式
      public static bool Graterthan(int first, int second)
      {
          return first > second;
      }
      //冒泡排序
      public static void BubbleSort(int[] items, ComparisonHander comparisonMethod)
      {
          int i;
          int j;
          int temp;
          if (comparisonMethod == null)
          {
              throw new ArgumentNullException("comparisonMethod");
          }
          if (items == null)
          {
              return;
          }
          for (i = items.Length - 1; i >= 0; i--)
          {
              for (j = 1; j <= i; j++)
              {
                  if (comparisonMethod(items[j - 1], items[j]))
                  {
                      temp = items[j - 1];
                      items[j - 1] = items[j];
                      items[j] = temp;
                  }
              }
          }
      }
      static void Main(string[] args)
      {
          int i;
          int[] items = new int[5];
          for(i=0; i<items.Length; i++)
          {
              Console.Write("Enter a integer: ");
              items[i] = int.Parse(Console.ReadLine());
          }
          //使用委托
          BubbleSort(items, Graterthan);
          for(i=0; i<items.Length; i++)
          {
              Console.WriteLine(items[i]);
          }
      }
  }
  }

• 关系图

  //使用Lambda表达式的冒泡函数调用
  //...
  //语句Lambda
  BubbleSort(items, (int first, int second) => {return first > second;});
  //表达式Lambda
  BubbleSort(items, (first,second) =>  first > second);

• [规范] 避免在新的代码中使用匿名方法语法, 应该优先使用更简洁的Lambda表达式

第十三章 事件