一：值类型/引用类型的区别

     值类型主要包括简单类型，枚举类型，和结构体类型等，值类型的实例通常被分配在线程堆栈上面变量保存的内容是实例数据本身。引用类型被分配在托管堆上，变量保存的是地址。引用类型主要包括类类型，接口类型，委托类型和字符串类型等。

关于参数传递，这里有四种：

       值类型参数的按值传递；

       引用类型参数按值传递；

关于string引用类型参数按值传递的特殊情况；虽然string类型也是引用类型，然而在按值传递时，传递的实参却不会因方法中形参的改变而被修改。

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("String引用类型按值传递的特殊情况");
            string str = "old string";         //引用类型
              ChangeStr(str);
            Console.WriteLine("调用之后的值："+str);
            Console.ReadKey();
        }

        private static void ChangeStr(string oldStr)
        {
             oldStr = "New string";
            Console.WriteLine("方法中的oldStr:"+oldStr);
        }
    }

   造成这个原因是由于：string具有不变性，一旦一个string类型被赋值，则它是不会改变的，即不能通过代码来修改它的值，图中好像是对str进行了修改，但是由于string类型的不可变性，系统会重新分配一块内存空间来存放New string字符串。把修改的内存首地址赋值给oldStr变量，所以值就发生了变化。

       值类型参数的按引用传递；

       引用类型参数的按引用传递；

这里就需要使用到ref,out这两个关键字了，他们是把值类型和引用类型都按照引用进行传递。

二：重新认识------泛型

     泛型(generic)：就是通用类型，它可以代替任意的数据类型，是类型参数化，从而达到只实现一个方法就可以操作多种数据类型的目的。泛型将方法实现行为和方法操作的数据类型分离，实现代码的重用。

            //用int作为实际参数来初始化泛型类型
              List<int> inList=new List<int>();
            inList.Add(3);
            //用string作为实际参数来初始化泛型类型
              List<string> inString=new List<string>();
            inString.Add("ahui");

上面的就是泛型，List<T>是.NET类库中实现的泛型类型，T是泛型参数(形参)，想实例化一个泛型类型，就必须传入实际的类型参数。

    /// <summary>
    /// 定义一个泛型---比较各种类型的大小。 IComparable接口是因为里面有个CompareTo方法
    /// </summary>
    /// <typeparam name="T">泛型的参数，就是传递来的类型</typeparam>
    public class Compare<T> where T:IComparable
    {              
        public static T CompareGeneric(T t1,T t2)
        {
            if (t1.CompareTo(t2)>0)
            {
                return t1;
            }
            else
            {
                return t2;
            }
        }
    }

这里面的T就是我们将来调用方法时往里面传递的类型（泛型的类型参数）。CompareGeneric是实现泛型的方法，代码中的where语句是类型参数的约束，它用来使类型参数可以适用于CompareTo方法。从而对类型参数进行约束。

            //调用泛型，直接点操作就可以来，只需要注意传递进去的类型就可以。
              Console.WriteLine(Compare<int>.CompareGeneric(1,2));
            Console.WriteLine(Compare<string>.CompareGeneric("2222","111"));
            Console.ReadKey();

   1：泛型除了可以实现代码的重用，还提供了更好的性能和类型安全特性。

   2：使用泛型可以减少装箱和拆箱带来的性能消耗。因为我们直接就是类型，不需要在将其转换为object类型再来进行操作。

   3：泛型代码中，T就是类型参数，无论调用类型方法还是初始化泛型实例，都需要用真实类型代替T。

   4：我们有的时候不需要给T赋值，编译器自己可以推测出T是什么类型的，这是类型参数的推断。(参数只能是一种类型)

   5：类型参数的约束：

共有4中约束，语法类似：约束要放在泛型方法或类型声明的末尾，并且要使用where关键字。

--->引用类型约束

      引用类型约束的表示形式为T:class，它确保传递的类型实参必须是引用类型。

    /// <summary>
    /// 引用类型约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Samplereference<T>where T:Stream      
    {
        public void Test(T stream)
        {
            stream.Close();
        }
    }

类型参数T设置了引用类型约束。where T:stream的意思就是告诉编译器，传递的类型必须是System.IO.Stream或者是其子类。

--->值类型约束

    表示形式：T:struct

    /// <summary>
    /// 值类型约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Samplevaluetype<T> where T:struct             //约束为结构体了，(值类型)
    {
        public static T Test()
        {
            return new T();   //T是一个值类型，所有的值类型都有一个公共的无参构造函数，
        }
    }

--->构造函数类型约束

    表示形式：T:new()，若是有多个约束此约束应该最后指定。

--->转换类型约束

    表示形式：T:基类名。T：接口名或T：U;

---->组合约束

就是将上面的都组合在一起，类必须放在接口前面，不同的类型参数可以有不同的约束，但每种类型参数必须分别使用一个单独的where关键字。

三：可空类型

    可空类型也是值类型，但它包含null值的值类型，

    int? a=null;

int ?就是可空的int类型，？修饰符只是C#的语法糖，就是C#提供的一种方便的表示形式。

四：空合并操作符(??)

     ??操作符，它会对左右两个操作数进行判断，如果左边的数不为null,就返回左边的数。如果左边的数为Null,就返回右边的数。主要用于可空类型，也可以用于引用类型的判空，但是不能用于值类型。

        /// <summary>
        /// ??运算符
        /// </summary>
        private static void NullcoalescingOperator()
        {
            int? nullable = null;
            int? nullhasvalue = 1;

            int x = nullable ?? 12;            //和三目运算符功能一样。
            int y = nullhasvalue ?? 123;
            Console.WriteLine("可空类型没有值："+x);
            Console.WriteLine("可空类型有值：" + y);

            Console.WriteLine();
            //??运于引用类型
            string stringnotnull = "123";
            string stringisnull = null;
            string result = stringnotnull ?? "456";
            string result2 = stringisnull ?? "12";
            Console.WriteLine("引用类型不为Null的情况："+result);
            Console.WriteLine("引用类型为Null的情况：" + result2);
        }

        static void Main(string[] args)
        {

            Console.WriteLine();
            NullcoalescingOperator();
            Console.ReadKey();

        }

使用??运算符可以很方便地设置默认值，避免了通过if,else语句来进行判断，从而简化了代码行数，提高了代码的可读性。

五：匿名方法

解释：就是没有名字的方法，因为没有名字，匿名方法只能在函数定义(就是把方法的定义和实现嵌套在一起)的时候被用。其它任何 情况下都不能被调用。

委托是匿名函数的前提。

    public class Friend
    {
        /// <summary>
        /// 实现委托的方法(就是委托要传递的方法)
        /// </summary>
        /// <param name="nickName"></param>
        public void Vote(string nickName)
        {
            Console.WriteLine("昵称为：{0},来了呀",nickName);
        }
    }

    class Program
    {
        //定义委托
        private delegate void VoteDelegate(string name);

        private static void Main(string[] args)
        {
            //实例化委托对象
            VoteDelegate voteDelegate = new VoteDelegate(new Friend().Vote); //Vote方法当作了参数来传递。
            voteDelegate("ahui"); //把ahui传递到了下面的方法中。
            Console.ReadKey();
        }
    }

下面是使用匿名函数

   class Program
    {
        //定义委托
        private delegate void VoteDelegate(string name);

        private static void Main(string[] args)
        {
            //使用匿名函数来实例化委托。必须为delegate。其余就和方法的一样。
             VoteDelegate voteDelegate = delegate(string nickName)
            {
                Console.WriteLine("昵称为：" + nickName);
            };
            //通过调用委托来回调Vote()方法，这是隐式调用方式。
              voteDelegate("ahui");
            Console.ReadKey();
        }
    }

我们使用匿名函数就不需要单独定义一个Vote方法，这减少了代码行数。

匿名函数的缺点：  

           不能被其他地方调用，容易形成闭包。