C#学习笔记（六）：可空类型、匿名方法和迭代器

可空类型

为啥要引入可空类型？

在数据库中，字段是可以为null值的，那么在C#中为了方便的操作数据库的值，微软引入了可空类型。

声明可空类型

我们可以使用两种方法声明一个可空类型：

 Nullable<int> i = null;
 int? i = null;

第二行是第一行的简写方法，其中“?”是微软为可空类型提供的一个语法糖。

我们看看可空类型的实现：

 // Type: System.Nullable`1
 // Assembly: mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
 // MVID: 255ABCDF-D9D6-4E3D-BAD4-F74D4CE3D7A8
 // Assembly location: C:\Windows\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll

 using System.Runtime;

 namespace System
 {
   /// <summary>
   /// 表示基础类型为值类型的对象，值类型与引用类型一样也可以分配 null。
   /// </summary>
   /// <typeparam name="T"><see cref="T:System.Nullable`1"/> 泛型类型的基础值类型。</typeparam><filterpriority></filterpriority>
   [Serializable]
   public struct Nullable<T> where T : struct
   {
     /// <summary>
     /// 将 <see cref="T:System.Nullable`1"/> 结构的新实例初始化为指定值。
     /// </summary>
     /// <param name="value">一个值类型。</param>
     [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
     public Nullable(T value);
     /// <summary>
     /// 创建一个新的 <see cref="T:System.Nullable`1"/> 对象，并将其初始化为指定的值。
     /// </summary>
     ///
     /// <returns>
     /// 一个 <see cref="T:System.Nullable`1"/> 对象，其 <see cref="P:System.Nullable`1.Value"/> 属性使用 <paramref name="value"/> 参数进行初始化。
     /// </returns>
     /// <param name="value">一个值类型。</param>
     public static implicit operator T?(T value);
     /// <summary>
     /// 返回指定的 <see cref="T:System.Nullable`1"/> 的值。
     /// </summary>
     ///
     /// <returns>
     /// <paramref name="value"/> 参数的 <see cref="P:System.Nullable`1.Value"/> 属性的值。
     /// </returns>
     /// <param name="value">一个 <see cref="T:System.Nullable`1"/> 值。</param>
     public static explicit operator T(T? value);
     /// <summary>
     /// 检索当前 <see cref="T:System.Nullable`1"/> 对象的值，或该对象的默认值。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，则为 <see cref="P:System.Nullable`1.Value"/> 属性的值；否则为当前 <see cref="T:System.Nullable`1"/> 对象的默认值。 默认值的类型为当前 <see cref="T:System.Nullable`1"/> 对象的类型参数，而默认值的值中只包含二进制零。
     /// </returns>
     [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
     public T GetValueOrDefault();
     /// <summary>
     /// 检索当前 <see cref="T:System.Nullable`1"/> 对象的值或指定的默认值。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，则为 <see cref="P:System.Nullable`1.Value"/> 属性的值；否则为 <paramref name="defaultValue"/> 参数。
     /// </returns>
     /// <param name="defaultValue">如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，则为一个返回值。</param>
     public T GetValueOrDefault(T defaultValue);
     /// <summary>
     /// 指示当前 <see cref="T:System.Nullable`1"/> 对象是否等于指定的对象。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <paramref name="other"/> 等于当前的 <see cref="T:System.Nullable`1"/> 对象，则为 true；否则为 false。 此表描述如何定义所比较值的相等性： 返回值 说明 true <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，并且 <paramref name="other"/> 参数为 null。 即，根据定义，两个 null 值相等。 - 或 - <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，并且 <see cref="P:System.Nullable`1.Value"/> 属性返回的值等于 <paramref name="other"/> 参数。 false 当前 <see cref="T:System.Nullable`1"/> 结构的 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，并且 <paramref name="other"/> 参数为 null。 - 或 - 当前 <see cref="T:System.Nullable`1"/> 结构的 <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，并且 <paramref name="other"/> 参数不为 null。 - 或 - 当前 <see cref="T:System.Nullable`1"/> 结构的 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，并且 <see cref="P:System.Nullable`1.Value"/> 属性返回的值不等于 <paramref name="other"/> 参数。
     /// </returns>
     /// <param name="other">一个对象。</param><filterpriority></filterpriority>
     public override bool Equals(object other);
     /// <summary>
     /// 检索由 <see cref="P:System.Nullable`1.Value"/> 属性返回的对象的哈希代码。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，则为 <see cref="P:System.Nullable`1.Value"/> 属性返回的对象的哈希代码；如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，则为零。
     /// </returns>
     /// <filterpriority></filterpriority>
     public override int GetHashCode();
     /// <summary>
     /// 返回当前 <see cref="T:System.Nullable`1"/> 对象的值的文本表示形式。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，则是当前 <see cref="T:System.Nullable`1"/> 对象的值的文本表示形式；如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，则是一个空字符串 ("")。
     /// </returns>
     /// <filterpriority></filterpriority>
     public override string ToString();
     /// <summary>
     /// 获取一个值，指示当前的 <see cref="T:System.Nullable`1"/> 对象是否有值。
     /// </summary>
     ///
     /// <returns>
     /// 如果当前的 <see cref="T:System.Nullable`1"/> 对象具有值，则为 true；如果当前的 <see cref="T:System.Nullable`1"/> 对象没有值，则为 false。
     /// </returns>
     public bool HasValue { [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get; }
     /// <summary>
     /// 获取当前的 <see cref="T:System.Nullable`1"/> 值。
     /// </summary>
     ///
     /// <returns>
     /// 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 true，则为当前 <see cref="T:System.Nullable`1"/> 对象的值。 如果 <see cref="P:System.Nullable`1.HasValue"/> 属性为 false，则将引发异常。
     /// </returns>
     /// <exception cref="T:System.InvalidOperationException"><see cref="P:System.Nullable`1.HasValue"/> 属性为 false。</exception>
     public T Value { [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] get; }
   }
 }

我们注意一下其类的声明：

public struct Nullable<T> where T : struct

首先，可空类型是值类型而不是引用类型。

where表明了其接受的类型仅仅是值类型，当然，引用类型天生就支持为null。

使用可空类型

我们来看一个使用可空的例子：

 using System;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             int? i = null;

             // GetValueOrDefault() 如果为空则返回默认值
             Console.WriteLine("是否有值：" + i.HasValue + ", 值：" + i.GetValueOrDefault());

             //赋值
             if (!i.HasValue)
             {
                 i = ;
             }

             Console.WriteLine("是否有值：" + i.HasValue + ", 值：" + i.Value);

             //int num = i * 2;
             //上面的写法会报错
             int num = i.Value * ;
             Console.WriteLine("num：" + num);

             if (i == )
             {
                 Console.WriteLine("等于100");
             }

             Console.Read();
         }
     }
 }

输出如下：

 是否有值：False, 值：
 是否有值：True, 值：
 num：
 等于100

空合并操作符

由于可空类型可以为空，所以，如果我们需要获取一个可空类型的值时，如果为null返回0，否则返回其自己的值，写法如下：

int i = nullable.HasValue ? nullable.Value : ;

我们还可以直接使用GetValueOrDefault();方法来获取，如果是为null需要一个指定的数，如100的写法如下：

 int i = nullable.HasValue ? nullable.Value : ;
 int i = nullable.GetValueOrDefault();

上面两种写法的效果一致。

下面我们来看看空合并操作符“??”的效果：判断左方的数，如果不为空则返回左方的数，否则返回右方的数。

比如上面的效果用空合并操作符来写如下：

int i = nullable ?? ;

我们可以把空操作符看做一种方便的简写形式。

匿名方法

委托、匿名函数、Lambda表达式和事件的学习

闭包

一般一个方法内部定义的值对象会在方法或其作用域结束时被系统回收，但是如果使用匿名函数和Lambda表达式时会引入一种新的情况，导致方法内部定义的值对象不会再方法结束时被回收，这种想象称为闭包。

闭包的概念：主要是指由函数以及与函数相关的上下文环境组成的实体，通过闭包，函数与上下文变量之间建立起关联关系，上下文变量的状态可以在函数的多次调用过程中持久保持，从作用域的角度而言，私有变量的生存期被延长，函数调用所生成的值在下次调用时仍被保持。从安全性的角度而言，闭包有利于信息隐蔽，私有变量只在该函数内可见。

形成闭包的条件：嵌套定义的函数、匿名函数、将函数作为参数或者返回值。

我们来看一个闭包的例子：

 using System;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             TCloser a = new TCloser();
             Func<int> b = a.T1();
             Console.WriteLine(b());

             Console.Read();
         }
     }

     public class TCloser
     {
         public Func<int> T1()
         {
             int n = ;
             return () =>
             {
                 Console.WriteLine(n);
                 return n;
             };
         }
     }
 }

我们会发现，例子中T1的局部变量n，在T1执行完毕后仍然被保留没有被系统回收，而在其返回的方法中可以被使用到，这就是闭包。

迭代器

IEnumerable、IEnumerator与yield的学习

yield学习续：yield return迭代块在Unity3D中的应用——协程