复习.Net高级

索引器：本质是封装了get，set方法，可以是只读或只写（在get或set前加上private），字符串是只读索引。

密闭类与静态类：

第一、密闭类是修饰为sealed的类，sealed不能有子类。String类无法被继承，因为String被声明了sealed。

第二、声明为static的类，不能实例化，只能定义static成员。通常用它定义扩展方法。

第三、C#3.0特性：扩展方法。声明静态类，增加一个静态方法，第一个参数是被扩展类型的标记为this，然后在其他类中可以直接调用。

static void Main(string[] args)
{
  string str = "Hello World!";
  str.ShowMsg(str);  
}

//扩展方法

static class MyString
{
  public static void ShowMsg(this string a,string msg)
  {
    Console.WriteLine(msg);
  }
}

深拷贝、浅拷贝：

深拷贝就是重新new一个对象，然后把之前的那个对象的属性值再重新赋值给这个用户。

static void Main(string[] args）
{
  MyCopy copy1 = new MyCopy();
  copy1.Name = "蛋蛋"；
  copy1.Age = 18;
  MyCopy copy2 = copy1;//浅拷贝
  Mycopy copy3 = new MyCopy();
  copy3.Name = copy1.Name;
  copy3.Age = copy1.Age;//浅拷贝
}

class MyCopy()
{
  public int Name{get;set;}
  public int Age{get;set}
}

CTS,CLS,CLR

CTS（Common Type System）通用数据类型

CLS（Common Language Specification）通用语法规范

CLR（Common Language Runtime）公共语言运行时

关于相等Equals：查看判断两个对象是否是同一个对象要用object.ReferenceEquals();

字符串暂存池：

string s1 = "rupeng";
string s2 = "rupeng";
stirng s3 = "ru"+"peng";
stirng s4 = new stirng(s1.ToCharArray());
string s5 = new string(new char[]{'r','u','p','e','n','g'});

s1,s2.s3是同一个字符串对象，在内容相同的情况下只有new才能产生一个一个新的字符串对象。

ref,out

ref的作用是“方法内部修改外部变量的引用”

out的作用是“方法内部给外部变量初始化，相当于一个函数多个返回值”

static void Main(string[] args)
{
  int i =1;
  int j = 2;
  int k;
  int result = Template(i,j,out k);
  Console.WriteLine(result+","+k);
  Console.ReadKey();
}
public static int Template(int i,int j,out int k)
{
  i=i+j;
  j=i-j;
  i=i-j;
  k=j;
  return i;
}

委托和事件

委托：委托是一种可以指向方法的数据类型。

delegate void MyDel(int n)//声明委托的方式：delegate 返回值类型 委托类型（参数），注意这里除了delegate，剩下部分和声明一个函数一样，但是MyDel不是函数名，而是委托类型名
MyDel sp = new MyDel(SayHello)//SayHello方法需要和MyDel的参数、返回值一样。简化方法MyDel sp = SayHello;

.Net中内置了两个泛型委托Func、Action，Func是有返回值的委托，Action是没有返回值的委托。

Action<string> ac = new Action<string>(Greeting);//没有返回值的内置委托
ac("蛋蛋");//调用Greeting方法

Func<string,string> fu = new Func<string,string>(GreetingForR);//有返回值的内置委托
string msg = fu("建国");

static string GreetingForR(string name)
{
  return name+"你好";
}
static void Greeting(string name)
{
  Console.WriteLine(name+"你好");
}

匿名方法

定义语法：MyDelegate p = delegate(int s){s=10;};

lambda表达式

Action<int> a1 = delegate(int i){Console.WriteLine(i);};

Action<int> a2 = (int i) =>{Console.WriteLine(i);}

Action<int> a3 = (i)=>{Console.WriteLine(i);};

Action<int> a4 = i=>{Console.WriteLine(i);};//只有一个参数可以省略小括号，多个参数不行

Func<int,int,string>  f1=delegate(int i,int j){return "结果是"+(i+j);};

Func<int,int,string> f2=(i,j)=>"结果是"+(i+j);

事件

事件语法：event Mydelegate mdl;

    delegate void MyDel();
    class Program
    {

        static void Main(string[] args)
        {
            person p = new person();
            p.QingZhu += ShowMsg;//加了event关键字实现事件机制的好处：用了event事件，不可以修改事件已经注册的值；不可以冒充进行事件通知了。只能+=、-=！
            p.age = 24;
            Console.ReadKey();
        }
        static void ShowMsg()
        {
            Console.WriteLine("今年是你的本命年！恭喜你");
        }
    }
    class person
    {
        private int Age;
        public int age
        {
            get
            {
                return age;
            }
            set
            {
                if (value % 12 == 0)
                {
                    if (QingZhu != null)
                    {
                        QingZhu();//执行事件
                    }
                }
            }
        }
        public event MyDel  QingZhu;
    }

委托和事件的总结

委托的作用：占位，在不知道要执行的方法的具体代码时，可以先用一个委托变量来替代方法调用。在实际调用之前，需要为委托赋值，否则为null。

事件的作用：作用与委托变量一样，只是功能上有更多限制。

二者关系：事件由一个私有的委托变量和add_***和remove_***方法组成

反射

获取类信息对象Type

从对象获取：Type type = person.getType();

从类名获取：Type type = typeof(Person);

从全类名（命名空间+类名）获取：Type type = Type.GetType("命名空间.类名");

使用情况：如果有一个对象，就用getType()获取，如果没有对象就用typeof;如果要运行通过配置文件拿到的字符串来获得就用Type.GetType("***");

序列化

BinaryFormatter类有两个方法：

void Serialize(Stream stream, object pbj)

对象obj序列化到Stream中

object Deserialize(Stream stream)

将对象从stream中反序列化，返回值为反序列化得到的对象

对象序列化的一些注意事项

要序列化的类型必须标记为：[Serializable]

该类型的父类也必须标记为： [Serializable]

该类型中的所有成员的类型也必须标记为： [Serializable]

序列化只会对类中的字段序列化,(只能序列化一些状态信息)

类结构修改后之前序列化的内容尽量不要用了，否则可能会出错