空接合运算符 ？？--- ？：--- int？ C#中的可空类型

 

 

??是个双目运算符，第一个操作数必须是一个可空类型，第二个操作数必须与第一个操作数类型相同或可以隐含的转换为第一个操作数类型，如果 ?? 运算符的左操作数非空，该运算符将返回左操作数，否则返回右操作数。

int? a=null;//定义一个可空类型a（a可以为null也可以放整形）

int b;

b=a??10;  //b has the value 10

a=3;

b=a??10;  //b has the value 3

-------------------------------------------------------------------------

条件运算符 (?:) 根据布尔型表达式的值返回两个值中的一个

条件运算符为右联运算符，因此该形式的表达式

a ? b : c ? d : e

按如下规则计算：

a ? b : (c ? d : e)
而不是按照下面这样计算：
(a ? b : c) ? d : e
不能重载条件运算符。

-------------------------------------------------------------------------

int?是一种类型，普通的int不能为null，而用int?，其值可以为null

int?或者Nullable <int>表示基础类型为值类型的对象，值类型与引用类型一样也可以分配 nullNothingnullptrnull 引用 
对于一个类型，如果既可以给它分配一个值，也可以给它分配 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing）（表示没有任何值），我们就说这个类型是可空的。因此，可空类型可表示一个值，或表示不存在任何值。例如，类似 String 的引用类型就是可空类型，而类似 Int32 的值类型不是可空类型。由于值类型的容量只够表示适合于该类型的值，因此它不可为空；值类型没有表示空值所需的额外容量。 

Nullable <T> 结构支持只将一个值类型用作可空类型，因为引用类型本身就是可空的。 

Nullable 类为 Nullable <T> 结构提供补充支持。Nullable 类支持获取可空类型的基础类型，以及对基础值类型不支持一般的比较和相等性操作的可空类型进行成对的比较和相等性操作。 

方案 
根据不同的应用场合，可使用可空类型来表示存在或不存在的内容。例如，HTML 标记的某个可选属性可能存在于某一个标记中，但不存在于另一个标记中；或者数据库表的某个可空列可能存在于表的某一行中，但不存在于另一行中。 

可将属性或列表示为类中的字段，并且可将该字段定义为值类型。该字段可包含属性或列的所有有效值，但不能提供一个附加值来表示属性或列不存在。在这种情况下，应将该字段定义为可空类型，而不是值类型。 

基本属性 
Nullable <T> 结构的两个基础成员为 HasValue 和 Value 属性。如果 Nullable <T> 对象的 HasValue 属性为 true，则可以使用 Value 属性访问该对象的值。如果 HasValue 属性为 false，则表示尚未定义该对象的值，并且尝试访问 Value 属性时会引发 InvalidOperationException。 

装箱和取消装箱 
在对可空类型进行装箱时，公共语言运行库自动将 Nullable <T> 对象的基础值（而不是 Nullable <T> 对象本身）装箱。也就是说，如果 HasValue 属性为 true，则将 Value 属性的内容装箱。在对可空类型的基础值进行取消装箱时，公共语言运行库创建一个新的初始化为基础值的 Nullable <T> 结构。 

如果可空类型的 HasValue 属性为 false，则装箱操作的结果为 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing）。因此，如果将已装箱的可空类型传递给需要对象参数的方法，则该方法必须准备处理参数为 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing） 的情况。如果对 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing） 进行取消装箱使其成为可空类型，则公共语言运行库会创建一个新的 Nullable <T> 结构并将其 HasValue 属性初始化为 false。

Nullable <T> 这个泛型类：

[Serializable, StructLayout(LayoutKind.Sequential), TypeDependency("System.Collections.Generic.NullableComparer`1"), TypeDependency("System.Collections.Generic.NullableEqualityComparer`1")] 
public struct Nullable <T> where T: struct 
{ 
    private bool hasValue; 
    internal T value; 
    public Nullable(T value) 
    { 
        this.value = value; 
        this.hasValue = true; 
    } 

    public bool HasValue 
    { 
        get 
        { 
            return this.hasValue; 
        } 
    } 
    public T Value 
    { 
        get 
        { 
            if (!this.HasValue) 
            { 
                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NoValue); 
            } 
            return this.value; 
        } 
    } 
    public T GetValueOrDefault() 
    { 
        return this.value; 
    } 

    public T GetValueOrDefault(T defaultValue) 
    { 
        if (!this.HasValue) 
        { 
            return defaultValue; 
        } 
        return this.value; 
    } 

    public override bool Equals(object other) 
    { 
        if (!this.HasValue) 
        { 
            return (other == null); 
        } 
        if (other == null) 
        { 
            return false; 
        } 
        return this.value.Equals(other); 
    } 

    public override int GetHashCode() 
    { 
        if (!this.HasValue) 
        { 
            return 0; 
        } 
        return this.value.GetHashCode(); 
    } 

    public override string ToString() 
    { 
        if (!this.HasValue) 
        { 
            return ""; 
        } 
        return this.value.ToString(); 
    } 

    public static implicit operator T?(T value) 
    { 
        return new T?(value); 
    } 

    public static explicit operator T(T? value) 
    { 
        return value.Value; 
    } 
}