一、[]
方括号 ([]) 用于数组、索引器和属性，也可用于指 针。
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 之 后的值。
第二种形式是 后缀增量操作。该运算的结果是操作数增加之前的值。
数值类型和枚举类型具有预定义的增量运算符。用户定义的类型可重载 ++ 运算符。在枚举时通常允许整型运算。

二十、--
减量运算符 (--) 将操作数减 1。减量运算符可以出现在操作数之前或之后：--variable 和 variable--。第一种形式是前缀减量操作。该运算的结果是操作数减小“之后”的值。第二种形式是后缀减量操作。该运算的结果 是操作数减小“之前”的值。
备注：
数值类型和枚举类型具有预定义的增量运算符。
用户定义的类型可重载 -- 运算符（请参见运算符）。在枚举时通常允许整型运算。

二十一、&&
条件“与”运 算符 (&&) 执行其 bool 操 作数的逻辑“与”运算，但仅在必要时才计算 第二个操作数。
备注：
操作
x && y
对应于操作
x & y
不同的是，如果 x 为 false，则不计算 y（因为不论 y 为何值，“与”操作的结果都为 false）。这被称作为“短路”计算。
不能重载条件“与”运 算符，但常规逻辑运算符和运算符 true 与 false 的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

二十二、||
条件“或”运 算符 (||) 执行 bool 操作数的 逻辑“或”运算，但仅在必要时才计算第二个 操作数。
备注：
操作
x || y
对应于操作
x | y
不同的是，如果 x 为 true，则不计算 y（因为不论 y 为何值，“或”操作的结果都为 true）。这被称作为“短路”计算。
不能重载条件“或”运 算符，但规则逻辑运算符和运算符 true 与 false 的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

二十三、<<
左移运算符 (<<) 将第一个操作数向左 移动第二个操作数指定的位数。第二个操作数的类型必须是 int。
备注：
如果第一个操作数是 int 或 uint（32 位数），则移位数由第二个操作数的低 5 位给 出。
如果第一个操作数 是 long 或 ulong（64 位数），则移位数由第二个操作数的低 6 位给 出。
第一个操作数的高 序位被放弃，低序空位用 0 填充。移位操作从不导致溢出。
用户定义的类型可重载 << 运算符（请参见 operator）； 第一个操作数的类型必须为用户定义的类型，第二个操作数的类型必须为 int。重载二元运算符时， 也会隐式重载相应的赋值运算符（如果有）。