Csharp+Asp.net系列教程（四）

迈克老猫
来自：老猫的理想

本教程参考C#和ASP.NET程序设计教程撰写，有什么不足之处请大家指出，或在老猫的理想BLOG留言。

这次简述一下操作符
     1.算术操作符
               算术操作符包括加(+)、减(-)、乘(*)、除(/)和求余(%)。加减操作符除了用于整数和实数的加减运算外，还适用于枚举类型、字符串类型和委托类型，这是通过操作符重栽实现的。
               string mf1="Mike";
               string mf2="Cat";
               string mf3=mf1+mf2;//mf3="MikeCat"
         
               using System;
               enum Weekday
               {
                    Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday
               };
               class MikeCat
               {
                    static void Main()
                    {
                         Weekday mf1=Weekday.Sunday;
                         Weekday mf2=mf1+3;
                         Console.WriteLine("mf1={0},mf2={1}",mf1,mf2);
                    }
               }//结果：mf1=Sunday,mf2=Wednesday
          2.赋值操作符
               赋值就是给一个变量赋一个新值。c#中分简单赋值和复合赋值两类。
                    简单赋值："=" a=b=c 等价于 a=(b=c)
                    复合赋值："+=" "-=" "*=" "/=" "%=" "|=" "^=" "<<=" ">>=" a+=10 等价于a=a+10
          3.比较操作符
               比较操作符用来比较两个表达式的大小，如大于(>) < == != <= >= 。
          4.逻辑操作符
               逻辑与(&&) 逻辑或(||) 和 逻辑非(!)
          5.位操作符是对数据按二进制位进行运算的操作符。c#位操作符包括按位与(&) | ~ << >>
                    using System;
                    class MikeCat
                    {
                         public static void Main()
                         {
                              int a=6&3;
                              Console.WriteLine("a={0}",a);
                              //6的二进制是00000110,3的二进制是00000011,按位与后等于00000010，即2
                              int b=6|3;
                              Console.WriteLine("b={0}",b);
                              //6的二进制是00000110,3的二进制是00000011,按位或后等于00000111，即7
                              int c=~6;
                              Console.WriteLine("c={0}",c);
                              //6的二进制是00000110,按位取反后是11111001即-7
                              int d=6^3;
                              Console.WriteLine("d={0}",d);
                              //6的二进制是00000110,3的二进制是00000011,按位异或后等于00000101，即5
                              int e=6<<3;
                              Console.WriteLine("e={0}",e);
                              //6的二进制是00000110,左移三位后等于00101000，即48
                              int f=6>>2;
                              Console.WriteLine("f={0}",f);
                              //6的二进制是00000110,右移二位等于00000001,即1
                         }
                    }
          6.is操作符
               is操作符用于检查运行时对象类型是否和给定的类型兼容。表达式"e is T"中的e是一个表达式，T是一个类型。返回值是一个布尔值。
               如果满足下列两个条件，则 is 表达式计算为 true 值：
                    expression 非 null。
                    expression 可以被转换为 type。也就是说，将完成形式 (type)(expression) 的转换表达式而不引发异常。
               示例
                    // cs_keyword_is.cs
                    // The is operator
                    using System;
                    class Class1
                    {
                    }
                    class Class2
                    {
                    }
                    public class IsTest
                    {
                    public static void Test (object o)
                    {
                    Class1 a;
                    Class2 b;
                    if (o is Class1)
                    {
                    Console.WriteLine ("o is Class1");
                    a = (Class1)o;
                    // do something with a
                    }          
                    else if (o is Class2)
                    {
                    Console.WriteLine ("o is Class2");
                    b = (Class2)o;
                    // do something with b
                    }
                    else
                    {
                    Console.WriteLine ("o is neither Class1 nor Class2.");
                    }
                    }
                    public static void Main()
                    {
                    Class1 c1 = new Class1();
                    Class2 c2 = new Class2();
                    Test (c1);
                    Test (c2);
                    Test ("a string");
                    }
                    }
                    输出
                    o is Class1
                    o is Class2
                    o is neither Class1 nor Class2.
          7.三元操作符
               三元操作符(?:)也称条件操作符。对条件表达式"b?x:y",总是先计算条件b，然后进行判断。如果b的值为true,则计算x的值，否则计算y的值。条件运算符为右联运算符，因此该形式的表达式 a ? b : c ? d : e 按如下规则计算：a ? b : (c ? d : e)
          8. . 运算符
               点运算符用于成员访问。name1 . name2
                         class Simple
                         {
                         public int a;
                         public void b()
                         {
                         }
                         }
                         Simple s = new Simple();
                         变量 s 有两个成员 a 和 b；若要访问这两个成员，请使用点运算符
                         s.a = 6; // assign to field a;
                         s.b(); // invoke member function b;

9.[] 运算符
               方括号 ([]) 用于数组、索引器和属性，也可用于指针。
               type [] array [ indexexpr ]
               其中： type 类型。 array 数组。 indexexpr 索引表达式
          10.() 运算符
               除了用于指定表达式中运算符的顺序外，圆括号还用于指定转换（类型转换）
               ( type ) expr      其中：type      expr 要转换为的类型名。 expr      一个表达式。转换显式调用从 expr 类型到 type 类型的转换运算符；如果未定义这样的转换运算符，则该转换将失败。
          12.自增自减操作符
               自增操作符++对变量的值加1，而自减操作符--对变量的值减1。此操作符有前后缀之分。对于前缀操作符，遵循的原则是“先增减，后使用”，而后缀操作符则正好相反，是“先使用，后增减”
               using System;
               class MikeCat
               {
                    public static void Main()
                    {
                         double x,y;
                         x=1.5;
                         Console.WriteLine(++x);//自增后等于2.5
                         y=1.5;
                         Console.WriteLine(y++);//先显示1.5后自增
                         Console.WriteLine(y);//自增后等于2.5
                    }
               }
          13.as 运算符
               as 运算符用于执行可兼容类型之间的转换。as 运算符用在以下形式的表达式中：expression as type      其中： expression      引用类型的表达式。type      引用类型。
               as 运算符类似于类型转换，所不同的是，当转换失败时，as 运算符将产生空，而不是引发异常。在形式上，这种形式的表达式：
               expression as type      等效于：
               expression is type ? (type)expression : (type)null
               只是 expression 只被计算一次。
               请注意，as 运算符只执行引用转换和装箱转换。as 运算符无法执行其他转换，如用户定义的转换，这类转换应使用 cast 表达式来代替其执行。
               using System;
               class MyClass1
               {
               }
               class MyClass2
               {
               }
               public class IsTest
               {
               public static void Main()
               {
               object [] myObjects = new object[6];
               myObjects[0] = new MyClass1();
               myObjects[1] = new MyClass2();
               myObjects[2] = "hello";
               myObjects[3] = 123;
               myObjects[4] = 123.4;
               myObjects[5] = null;
               for (int i=0; i                {
               string s = myObjects[i] as string;
               Console.Write ("{0}:", i);
               if (s != null)
               Console.WriteLine ( "'" + s + "'" );
               else
               Console.WriteLine ( "not a string" );
               }
               }
               }
               输出
               0:not a string
               1:not a string
               2:'hello'
               3:not a string
               4:not a string
               5:not a string
          14.new 操作符
                    new操作符用于创建一个新的类型实例，有三种形式：
                    A:对象创建表达式，用于创建一个类类型或值类型的实例。
                    B:数组创建表达式，用于创建一个数组类型实例。
                    C:委托创建表达式，用于创建一个新的委托类型实例。
          15.typeof操作符
                    typeof操作符用于获得系统原型对象的类型。
                    using System;
                    class MikeCat
                    {
                         public static void Main()
                         {
                              Console.WriteLine(typeof(int));
                              Console.WriteLine(typeof(System.Int32));
                         }
                    }//结果：System.Int32 System.Int32
                    //表明int和System.Int32是同一个类型
               c#中用GetType()方法获得一个表达式在运行时的类型
                         using System;
                         class MikeCat
                         {
                              public static void Main()
                              {
                                   int r=3;
                                   Console.WriteLine("圆的面积等于{0}",r*r*Math.PI);
                                   Console.WriteLine("类型是{0}",(r*r*Math.PI).GetType());
                              }
                         }//圆的面积等于28.2743338823081
                         //类型是System.Double
          16.sizeof操作符
                    sizeof操作符获得一个值类型的字节大小
                              using System;
                              class MikeCat
                              {
                                   unsafe public static void SizesOf()
                                   {
                                        Console.WriteLine("short的大小是{0}",sizeof(short));
                                        Console.WriteLine("int的大小是{0}",sizeof(int));
                                        Console.WriteLine("long的大小是{0}",sizeof(long));
                                   }
                                   public static void Main()
                                   {
                                        SizesOf();
                                   }
                              }//short 的大小是2;int的大小是4;long的大小是8;
          17.checked和unchecked操作符
               在进行整型算术运算或从一种整型显示转换到另外一种整型时，有可能产生溢出。
               检查这种溢出c#中有两种处理方式：
               第一：在编译时设置溢出校验选项（溢出校验默认是禁用的）：
                    csc /checked test.cs //这个我们在前面有所介绍
               第二：使用checked和unchecked操作符来确定是否进行溢出校验。即使编译时禁用溢出校验，计算时也同样引发异常。
                    using System;
                    class MikeCat
                    {
                         public static void Main(string[] args)
                         {
                              long factorial=1;
                              long num=Int64.Parse(args[0]);
                              for(long cur=1;cur<=num;cur++)
                                   {
                                        checked{factorial*=cur;}
                                   }
                                   Console.WriteLine("{0}的阶乘是{1}",num,factorial);
                         }
                    }//test.exe 3 3的阶乘是6
          unchecked操作符与checked操作符正好相反，即使溢出，被unchecked操作符所括住的代码也不会引发异常。
          各个操作符的优先级我就不在这里多说了。主要是手累。呵呵。仍然和以前c++的优先级相似。详细可参看MSDN。感谢大家关注本教程，欢迎访问老猫的理想BLOG。