第一章 ASP.net C#基本语法（B篇 程序结构、运算符、运算优先级）

在上一部分中我们做了一个简单的ASP.net的程序，但是简单中真的简约吗？VS2010的模板提供了那些东西呢？单位现在需要计算很多的数字。如何实现呢？豆豆做了一个计算公式。做的是“惊天地泣鬼神”啊！可是结果！算出来一个怪胎！这不郁闷着呢！

本章目标：了解程序模板的结构，能够使用运算符，详细剖析和熟练掌握运算的优先级

本章结构

第一部分：项目结构

先看图

新建立的ASP.net怎么有这么多东西？没有？你建立一个ASP.net项目，按Ctrl+Alt+L看看

现在解读一下里面的项目

VS2010里面模板带的页面比VS以前的版本要多很多，结构更加的清晰了。希望大家保持这种清晰的方式来做页面

注意：没一个aspx都带一个aspx.cs,其中aspx页面实现前台的页面显示，也就是浏览器看到的内容。前台提交的处理由后台的aspx.cs进行处理，其处理过程浏览器是看不到的，这样很有效的提高的程序的安全性和逻辑性。

第二部分：程序结构

如下图：

第三部分：运算符

一、[]

方括号 ([]) 用于数组、索引器和属性，也可用于指针。

1、数组类型是一种后跟 [] 的类型：

int[] fib = new int[100]; //创建一个有100元素的数组

若要访问数组的一个元素，则用方括号括起所需元素的索引：

fib[0] = fib[1] = 1;

for( int i=2; i<100; ++i ) fib[i] = fib[i-1] + fib[i-2];// 如果数组索引超出范围，则会引发异常。

2、不能重载数组索引运算符；但类型可以定义采用一个或多个参数的索引器和属性。索引器参数括在方括号中（就像数组索引一样），但索引器参数可声明为任何类型（这与数组索引不同，数组索引必须为整数）。

例如，.NET Framework 定义 Hashtable 类型，该类型将键和任意类型的值关联在一起。

Collections.Hashtable h = new Collections.Hashtable();

h["a"] = 123; // note: using a string as the index

3、方括号还用于指定属性（C# 编程指南）：

[attribute(AllowMultiple=true)]

public class Attr

{

}

4、可以使用方括号来指定指针索引：

unsafe fixed ( int* p = fib )   // p points to fib from earlier example

{

    p[0] = p[1] = 1;

    for( int i=2; i<100; ++i ) p[i] = p[i-1] + p[i-2];

}

二、()

除了用于指定表达式中的运算顺序外，圆括号还用于指定强制转换或类型转换：

double x = 1234.7;

int a;

a = (int)x; // cast double to int

三、.

点运算符 (.) 用于成员访问。点运算符指定类型或命名空间的成员。例如，点运算符用于访问 .NET Framework 类库中的特定方法：

System.Console.WriteLine("hello");

四、::

命名空间别名限定符运算符 (::)，用于查找标识符。它通常放置在两个标识符之间，例如：

global::System.Console.WriteLine("Hello World");

备注：

命名空间别名限定符可以是 global。这将调用全局命名空间中的查找，而不是在别名命名空间中。

五、+

+ 运算符既可作为一元运算符也可作为二元运算符。

备注：

一元 + 运算符是为所有数值类型预定义的。对数值类型进行一元 + 运算的结果就是操作数的值。

为数值类型和字符串类型预定义了二元 + 运算符。对于数值类型，+ 计算两个操作数之和。当其中的一个操作数是字符串类型或两个操作数都是字符串类型时，+ 将操作数的字符串表示形式串联在一起。

委托类型也提供二元 + 运算符，该运算符执行委托串联。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(+5);        // unary plus

        Console.WriteLine(5 + 5);     // addition

        Console.WriteLine(5 + .5);    // addition

        Console.WriteLine("5" + "5"); // string concatenation

        Console.WriteLine(5.0 + "5"); // string concatenation

        // note automatic conversion from double to string

    }

}

六、-

- 运算符既可作为一元运算符也可作为二元运算符。

一元 - 运算符是为所有数值类型预定义的。数值类型的一元 - 运算的结果是操作数的反数。

二元 - 运算符是为所有数值类型和枚举类型预定义的，其功能是从第一个操作数中减去第二个操作数。

委托类型也提供二元 - 运算符，该运算符执行委托移除。

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        Console.WriteLine(-a);

        Console.WriteLine(a - 1);

        Console.WriteLine(a - .5);

    }

}

七、*

乘法运算符 (*)，用于计算操作数的积。另外还用作取消引用运算符，允许读取和写入指针。

备注：

所有数值类型都具有预定义的乘法运算符。

* 运算符还用来声明指针类型和取消引用指针。该运算符只能在不安全的上下文中使用，通过 unsafe 关键字的使用来表示，并且需要 /unsafe 编译器选项。取消引用运算符也称为间接寻址运算符。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(5 * 2);

        Console.WriteLine(-.5 * .2);

        Console.WriteLine(-.5m * .2m); // decimal type

    }

}

八、/

除法运算符 (/) 用第二个操作数除第一个操作数。所有数值类型都具有预定义的除法运算符。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(-5/2);

        Console.WriteLine(-5.0/2);

    }

}

九、%

模数运算符 (%) 计算第二个操作数除第一个操作数后的余数。所有数值类型都具有预定义的模数运算符。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(5 % 2);       // int

        Console.WriteLine(-5 % 2);      // int

        Console.WriteLine(5.0 % 2.2);   // double

        Console.WriteLine(5.0m % 2.2m); // decimal

        Console.WriteLine(-5.2 % 2.0); // double

    }

}

十、&

& 运算符既可作为一元运算符也可作为二元运算符。

备注：

一元 & 运算符返回操作数的地址（要求 unsafe 上下文）。

为整型和 bool 类型预定义了二进制 & 运算符。对于整型，& 计算操作数的逻辑按位“与”。对于 bool 操作数，& 计算操作数的逻辑“与”；也就是说，当且仅当两个操作数均为 true 时，结果才为 true。

& 运算符计算两个运算符，与第一个操作数的值无关。例如：

int i = 0;

if (false & ++i == 1)

{

}

十一、|

二元 | 运算符是为整型和 bool 类型预定义的。对于整型，| 计算操作数的按位“或”结果。对于 bool 操作数，| 计算操作数的逻辑“或”结果；也就是说，当且仅当两个操作数均为 false 时，结果才为 false。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(true | false); // logical or

        Console.WriteLine(false | false); // logical or

        Console.WriteLine("0x{0:x}", 0xf8 | 0x3f);   // bitwise or

    }

}

十二、^

二元 ^ 运算符是为整型和 bool 类型预定义的。对于整型，^ 将计算操作数的按位“异或”。对于 bool 操作数，^ 将计算操作数的逻辑“异或”；也就是说，当且仅当只有一个操作数为 true 时，结果才为 true。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(true ^ false); // logical exclusive-or

        Console.WriteLine(false ^ false); // logical exclusive-or

        // Bitwise exclusive-or:

        Console.WriteLine("0x{0:x}", 0xf8 ^ 0x3f);

    }

}

十三、!

逻辑非运算符 (!) 是对操作数求反的一元运算符。为 bool 定义了该运算符，当且仅当操作数为 false 时才返回 true。

using System;

class MainClass

{

    static void Main()

{

        Console.WriteLine(!true);

        Console.WriteLine(!false);

    }

}

十四、~

~ 运算符对操作数执行按位求补运算，其效果相当于反转每一位。按位求补运算符是为 int、uint、long 和 ulong 类型预定义的。

using System;

class MainClass

{

    static void Main()

    {

        int[] values = { 0, 0x111, 0xfffff, 0x8888, 0x22000022};

        foreach (int v in values)

        {

            Console.WriteLine("~0x{0:x8} = 0x{1:x8}", v, ~v);

        }

    }

}

十五、=

赋值运算符 (=) 将右操作数的值存储在左操作数表示的存储位置、属性或索引器中，并将值作为结果返回。操作数的类型必须相同（或右边的操作数必须可以隐式转换为左边操作数的类型）。

using System;

class MainClass

{

    static void Main()

    {

        double x;

        int i;

        i = 5; // int to int assignment

        x = i; // implicit conversion from int to double

        i = (int)x; // needs cast

        Console.WriteLine("i is {0}, x is {1}", i, x);

        object obj = i;

        Console.WriteLine("boxed value = {0}, type is {1}",

                  obj, obj.GetType());

        i = (int)obj;

        Console.WriteLine("unboxed: {0}", i);

    }

}

十六、<

所有数值和枚举类型都定义“小于”关系运算符 (<)，如果第一个操作数小于第二个操作数，该运算符返回 true，否则返回 false。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(1 < 1.1);

        Console.WriteLine(1.1 < 1.1);

    }

}

十七、>

所有数值类型和枚举类型都定义“大于”关系运算符 >，如果第一个操作数大于第二个操作数，它将返回 true，否则返回 false。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(1.1 > 1);

        Console.WriteLine(1.1 > 1.1);

    }

}

十八、?:

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

condition ? first_expression : second_expression;

备注：

如果条件为 true，则计算第一表达式并以它的计算结果为准；如果为 false，则计算第二表达式并以它的计算结果为准。只计算两个表达式中的一个。

使用条件运算符，可以更简洁、雅观地表达那些否则可能要求 if-else 结构的计算。例如，为在 sin 函数的计算中避免被零除，可编写为

if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;

或使用条件运算符，

s = x != 0.0 ? Math.Sin(x)/x : 1.0;

十九、++

增量运算符 (++) 将操作数加 1。增量运算符可以出现在操作数之前或之后：

备注：

第一种形式是前缀增量操作。该操作的结果是操作数加 1 之后的值。

第二种形式是后缀增量操作。该运算的结果是操作数增加之前的值。

数值类型和枚举类型具有预定义的增量运算符。用户定义的类型可重载 ++ 运算符。在枚举时通常允许整型运算。

// cs_operator_increment.cs

using System;

class MainClass

{

    static void Main()

    {

        double x;

        x = 1.5;

        Console.WriteLine(++x);

        x = 1.5;

        Console.WriteLine(x++);

        Console.WriteLine(x);

    }

}

二十、--

减量运算符 (--) 将操作数减 1。减量运算符可以出现在操作数之前或之后：--variable 和 variable--。第一种形式是前缀减量操作。该运算的结果是操作数减小“之后”的值。第二种形式是后缀减量操作。该运算的结果是操作数减小“之前”的值。

备注：

数值类型和枚举类型具有预定义的增量运算符。

用户定义的类型可重载 -- 运算符（请参见运算符）。在枚举时通常允许整型运算。

// cs_operator_decrement.cs

using System;

class MainClass

{

    static void Main()

    {

        double x;

        x = 1.5;

        Console.WriteLine(--x);

        x = 1.5;

        Console.WriteLine(x--);

        Console.WriteLine(x);

    }

}

二十一、&&

条件“与”运算符 (&&) 执行其 bool 操作数的逻辑“与”运算，但仅在必要时才计算第二个操作数。

备注：

操作

x && y

对应于操作

x & y

不同的是，如果 x 为 false，则不计算 y（因为不论 y 为何值，“与”操作的结果都为 false）。这被称作为“短路”计算。

不能重载条件“与”运算符，但常规逻辑运算符和运算符 true 与 false 的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

示例

在下面的示例中，请观察使用 && 的表达式只计算第一个操作数。

using System;

class MainClass

{

    static bool Method1()

    {

        Console.WriteLine("Method1 called");

        return false;

    }

    static bool Method2()

    {

        Console.WriteLine("Method2 called");

        return true;

    }

    static void Main()

    {

        Console.WriteLine("regular AND:");

        Console.WriteLine("result is {0}", Method1() & Method2());

        Console.WriteLine("short-circuit AND:");

        Console.WriteLine("result is {0}", Method1() && Method2());

    }

}

二十二、||

条件“或”运算符 (||) 执行 bool 操作数的逻辑“或”运算，但仅在必要时才计算第二个操作数。

备注：

操作

x || y

对应于操作

x | y

不同的是，如果 x 为 true，则不计算 y（因为不论 y 为何值，“或”操作的结果都为 true）。这被称作为“短路”计算。

不能重载条件“或”运算符，但规则逻辑运算符和运算符 true 与 false 的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

示例

在下面的示例中，请观察使用 || 的表达式只计算第一个操作数。

using System;

class MainClass

{

    static bool Method1()

    {

        Console.WriteLine("Method1 called");

        return true;

    }

    static bool Method2()

    {

        Console.WriteLine("Method2 called");

        return false;

    }

    static void Main()

    {

        Console.WriteLine("regular OR:");

        Console.WriteLine("result is {0}", Method1() | Method2());

        Console.WriteLine("short-circuit OR:");

        Console.WriteLine("result is {0}", Method1() || Method2());

    }

}

二十三、<<

左移运算符 (<<) 将第一个操作数向左移动第二个操作数指定的位数。第二个操作数的类型必须是 int。

备注：

如果第一个操作数是 int 或 uint（32 位数），则移位数由第二个操作数的低 5 位给出。

如果第一个操作数是 long 或 ulong（64 位数），则移位数由第二个操作数的低 6 位给出。

第一个操作数的高序位被放弃，低序空位用 0 填充。移位操作从不导致溢出。

用户定义的类型可重载 << 运算符（请参见 operator）；第一个操作数的类型必须为用户定义的类型，第二个操作数的类型必须为 int。重载二元运算符时，也会隐式重载相应的赋值运算符（如果有）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int i = 1;

        long lg = 1;

        Console.WriteLine("0x{0:x}", i << 1);

        Console.WriteLine("0x{0:x}", i << 33);

        Console.WriteLine("0x{0:x}", lg << 33);

    }

}

二十四、>>

右移运算符 (>>) 将第一个操作数向右移动第二个操作数所指定的位数。

备注：

如果第一个操作数为 int 或 uint（32 位数），则移位数由第二个操作数的低五位给出（第二个操作数 & 0x1f）。

如果第一个操作数为 long 或 ulong（64 位数），则移位数由第二个操作数的低六位给出（第二个操作数 & 0x3f）。

如果第一个操作数为 int 或 long，则右移位是算术移位（高序空位设置为符号位）。如果第一个操作数为 uint 或 ulong 类型，则右移位是逻辑移位（高位填充 0）。

用户定义的类型可重载 >> 运算符；第一个操作数的类型必须为用户定义的类型，第二个操作数的类型必须为 int。有关更多信息，请参见 operator。重载二元运算符时，也会隐式重载相应的赋值运算符（如果有）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int i = -1000;

        Console.WriteLine(i >> 3);

    }

}

二十五、==

对于预定义的值类型，如果操作数的值相等，则相等运算符 (==) 返回 true，否则返回 false。对于 string 以外的引用类型，如果两个操作数引用同一个对象，则 == 返回 true。对于 string 类型，== 比较字符串的值。

备注：

用户定义的值类型可重载 == 运算符（请参见 operator）。用户定义的引用类型也可重载 == 运算符，尽管在默认情况下，无论对于预定义的引用类型还是用户定义的引用类型，== 的行为都与上面描述的相同。如果重载 ==，则还必须重载 !=。在枚举时通常允许整型运算。

示例

using System;

class MainClass

{

    static void Main()

    {

        // Numeric equality: True

        Console.WriteLine((2 + 2) == 4);

        // Reference equality: different objects,

        // same boxed value: False.

        object s = 1;

        object t = 1;

        Console.WriteLine(s == t);

        // Define some strings:

        string a = "hello";

        string b = String.Copy(a);

        string c = "hello";

        // Compare string values of a constant and an instance: True

        Console.WriteLine(a == b);

        // Compare string references;

        // a is a constant but b is an instance: False.

        Console.WriteLine((object)a == (object)b);

        // Compare string references, both constants

        // have the same value, so string interning

        // points to same reference: True.

        Console.WriteLine((object)a == (object)c);

    }

}

二十六、!=

如果操作数相等，则不等运算符 (!=) 返回 false，否则，返回 true。为所有类型（包括字符串和对象）预定义了不等运算符。用户定义的类型可重载 != 运算符。

备注：

对于预定义的值类型，如果操作数的值不同，则不等运算符 (!=) 返回 true，否则，返回 false。对于 string 以外的引用类型，如果两个操作数引用不同的对象，则 != 返回 true。对于 string 类型，!= 比较字符串的值。

用户定义的值类型可重载 != 运算符（请参见 operator）。用户定义的引用类型也可重载 != 运算符，尽管在默认情况下，无论对于预定义的引用类型还是用户定义的引用类型，!= 的行为都与上面描述的相同。如果重载 !=，则还必须重载 ==。在枚举时通常允许整型运算。

示例

using System;

class MainClass

{

    static void Main()

    {

        // Numeric inequality:

        Console.WriteLine((2 + 2) != 4);

        // Reference equality: two objects, same boxed value

        object s = 1;

        object t = 1;

        Console.WriteLine(s != t);

        // String equality: same string value, same string objects

        string a = "hello";

        string b = "hello";

        // compare string values

        Console.WriteLine(a != b);

        // compare string references

        Console.WriteLine((object)a != (object)b);

    }

}

二十七、<=

所有数值和枚举类型都定义了“小于等于”关系运算符 (<=)，如果第一个操作数小于或等于第二个操作数，则该运算符将返回 true，否则返回 false。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(1 <= 1.1);

        Console.WriteLine(1.1 <= 1.1);

    }

}

二十八、>=

所有数值类型和枚举类型都定义“大于等于”关系运算符 >=，如果第一个操作数大于或等于第二个操作数，该运算符将返回 true，否则返回 false。

using System;

class MainClass

{

    static void Main()

    {

        Console.WriteLine(1.1 >= 1);

        Console.WriteLine(1.1 >= 1.1);

    }

}

二十九、+=

加法赋值运算符。

备注：

使用 += 赋值运算符的表达式，例如

x += y

等效于

x = x + y

不同的是 x 只计算一次。+ 运算符的含义取决于 x 和 y 的类型（例如，对于数值操作数，其含义为相加；对于字符串操作数，其含义为串联）。

不能直接重载 += 运算符，但用户定义的类型可以重载 + 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        a += 6;

        Console.WriteLine(a);

        string s = "Micro";

        s += "soft";

        Console.WriteLine(s);

    }

}

三十、-=

减法赋值运算符。

备注：

使用 -= 赋值运算符的表达式，如

x -= y

等效于

x = x - y

不同的是 x 只计算一次。- 运算符的含义取决于 x 和 y 的类型（例如，对于数值操作数，其含义为相减；对于委托操作数，其含义为移除）。

不能直接重载 -= 运算符，但用户定义的类型可重载 - 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        a -= 6;

        Console.WriteLine(a);

    }

}

三十一、*=

二元乘法赋值运算符。

备注：

使用 *= 赋值运算符的表达式，如

x *= y

等效于

x = x * y

不同的是 x 只计算一次。为数值类型预定义了 * 运算符以执行乘法操作。

不能直接重载 *= 运算符，但用户定义的类型可重载 * 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        a *= 6;

        Console.WriteLine(a);

    }

}

三十二、/=

除法赋值运算符。

备注：

使用 /= 赋值运算符的表达式，如

x /= y

等效于

x = x / y

不同的是 x 只计算一次。为数值类型预定义了 / 运算符以执行除法操作。

不能直接重载 /= 运算符，但用户定义的类型可重载 / 运算符（请参见 operator）。对于所有复合赋值运算符，隐式重载二元运算符会重载等效的复合赋值。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        a /= 6;

        Console.WriteLine(a);

        double b = 5;

        b /= 6;

        Console.WriteLine(b);

    }

}

三十三、%=

模块赋值运算符。

备注：

使用 %= 赋值运算符的表达式，如

x %= y

等效于

x = x % y

不同的是 x 只计算一次。为数值类型预定义了 % 运算符，以计算相除后的余数。

不能直接重载 %= 运算符，但用户定义的类型可重载 % 运算符（请参见运算符（C# 参考））。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 5;

        a %= 3;

        Console.WriteLine(a);

    }

}

三十四、&=

“与”赋值运算符。

备注：

使用 &= 赋值运算符的表达式，如

x &= y

等效于

x = x & y

不同的是 x 只计算一次。& 运算符对整数操作数执行按位逻辑“与”运算，对 bool 操作数执行逻辑“与”运算。

不能直接重载 &= 运算符，但用户定义的类型可重载二元 & 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 0x0c;

        a &= 0x06;

        Console.WriteLine("0x{0:x8}", a);

        bool b = true;

        b &= false;

        Console.WriteLine(b);

    }

}

三十五、|=

“或”赋值运算符。

备注：

使用 |= 赋值运算符的表达式，例如

x |= y

等效于

x = x | y

不同的是 x 只计算一次。| 运算符对整型操作数执行按位逻辑“或”运算，对布尔操作数执行逻辑“或”运算。

不能直接重载 |= 运算符，但用户定义的类型可以重载 | 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 0x0c;

        a |= 0x06;

        Console.WriteLine("0x{0:x8}", a);

        bool b = true;

        b |= false;

        Console.WriteLine(b);

    }

}

三十六、^=

“异或”赋值运算符。

备注：

下列形式的表达式

x ^= y

按如下规则计算：

x = x ^ y

不同的是 x 只计算一次。^ 运算符对整数操作数执行按位“异或”运算，对 bool 操作数执行逻辑“异或”运算。

不能直接重载 ^= 运算符，但用户定义的类型可重载 ! 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 0x0c;

        a ^= 0x06;

        Console.WriteLine("0x{0:x8}", a);

        bool b = true;

        b ^= false;

        Console.WriteLine(b);

    }

}

三十七、<<=

左移赋值运算符。

备注：

下列形式的表达式

x <<= y

按如下规则计算：

x = x << y

不同的是 x 只计算一次。<< 运算符将 x 向左移动 y 指定的位数。

不能直接重载 <<= 运算符，但用户定义的类型可重载 << 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 1000;

        a <<= 4;

        Console.WriteLine(a);

    }

}

三十八、>>=

右移赋值运算符。

备注：

下列形式的表达式

x >>= y

按如下规则计算：

x = x >> y

不同的是 x 只计算一次。>> 运算符根据 y 指定的量对 x 进行右移位。

不能直接重载 >>= 运算符，但用户定义的类型可重载 >> 运算符（请参见 operator）。

示例

using System;

class MainClass

{

    static void Main()

    {

        int a = 1000;

        a >>= 4;

        Console.WriteLine(a);

    }

}

三十九、->

-> 运算符将指针取消引用与成员访问组合在一起。

备注：

以下形式的表达式

x->y

（其中 x 为 T* 类型的指针，y 为 T 的成员）等效于

(*x).y

-> 运算符只能在非托管代码中使用。

不能重载 -> 运算符。

示例

// cs_operator_dereferencing.cs

// compile with: /unsafe

using System;

struct Point

{

    public int x, y;

}

class MainClass

{

    unsafe static void Main()

    {

        Point pt = new Point();

        Point* pp = &pt;

        pp->x = 123;

        pp->y = 456;

        Console.WriteLine ( "{0} {1}", pt.x, pt.y );

    }

}

四十、??

如果 ?? 运算符的左操作数非空，该运算符将返回左操作数，否则返回右操作数。

备注：

可空类型可以包含值，或者可以是未定义的。?? 运算符定义当可空类型分配给非可空类型时返回的默认值。如果在将可空类型分配给非可空类型时不使用 ?? 运算符，将生成编译时错误。如果使用强制转换，并且当前未定义可空类型，将发生 InvalidOperationException 异常。

示例

using System;

class MainClass

{

    static int? GetNullableInt()

    {

        return null;

    }

    static string GetStringValue()

    {

        return null;

    }

    static void Main()

    {

        // ?? operator example.

        int? x = null;

        // y = x, unless x is null, in which case y = -1.

        int y = x ?? -1;

        // Assign i to return value of method, unless

        // return value is null, in which case assign

        // default value of int to i.

        int i = GetNullableInt() ?? default(int);

        string s = GetStringValue();

        // ?? also works with reference types.

        // Display contents of s, unless s is null,

        // in which case display "Unspecified".

        Console.WriteLine(s ?? "Unspecified");

    }

第四部分：运算符优先级排列如下

基本

x.y

f(x)

a[x]

x++

x--

new

typeof

checked

unchecked

-> 

一元

+

-

!

~

++x

--x

(T)x

True

False

&

sizeof 

乘法 *

/

% 

加法 +

- 

变换

<<

>> 

关系和类型检测

<

>

<=

>=

is

as 

相等

==

!= 

逻辑“与”

& 

逻辑XOR

^ 

逻辑“或”

| 

条件 AND

&& 

条件 OR

|| 

条件运算

?: 

赋值

=

+=

-=

*=

/=

%=

&=

|=

^=

<<=

>>=

??

总结：今天学习了程序结构，运算符，优先级，需要多多练习，方可掌握。