namespace ConsoleApplication2
{
    class Program
    {
        delegate double ProcessDelegate(double param1, double param2);
        static double Multiply(double param1, double param2)
        {
            return param1*param2;
        }
        static double Divide(double param1, double param2)
        {
            return param1/param2;
        }

        static void Main(string[] args)
        {
            ProcessDelegate process;
            Console.WriteLine("Enter 2 numbers separated with a comma:");
            string input = Console.ReadLine();
            int commaPos = input.IndexOf(',');
            double param1 = Convert.ToDouble(input.Substring(0, commaPos));
            double param2 = Convert.ToDouble(input.Substring(commaPos + 1,
            input.Length - commaPos - 1));
            Console.WriteLine("Enter M to multiply or D to divide:");
            input = Console.ReadLine();
            if (input == "M")
                process = new ProcessDelegate(Multiply);
            else
                process = new ProcessDelegate(Divide);
            Console.WriteLine("Result: {0}", process(param1, param2));
            Console.ReadKey();
        }
    }

}

static void Main（string［］ args）
　　｛//语句块包含在｛｝中
　　　　int MyInterger;//语句以;结束
　　　　string   MyString;///忽略空白字符(空格/回车/TAB)
　　　　MyInterger = 17;
　　｝

static void Main（string［］ args）
｛
    short shortResult, shortVal = 4;
    int integerVal = 67;
    long longResult;
    float floatVal = 10.5F;
    double doubleResult, doubleVal = 99.999;
    string stringResult, stringVal = "17";
    bool boolVal = true;

    Console.WriteLine（"Variable Conversion Examples\n数据类型转换范例\n"）;
    doubleResult = floatVal * shortVal;
    Console.WriteLine（"Implicit,->double:｛0｝*｛1｝->｛2｝", floatVal, shortVal, doubleResult）;
    shortResult = （short）floatVal;
    Console.WriteLine（"Implicit,->short:｛0｝->｛1｝", floatVal, shortResult）;
    stringResult = Convert.ToString（boolVal） + Convert.ToString（doubleVal）;
    Console.WriteLine（"Explicit,->string:\"｛0｝\"+\"｛1｝\"->｛2｝", boolVal, doubleVal, stringResult）;
    longResult = integerVal + Convert.ToInt64（stringVal）;
    Console.WriteLine（"Mixed,->long ｛0｝+｛1｝->｛2｝", integerVal, stringVal, longResult）;

｝

int i;
string text;//在循环外未初始化
for (i = 0;i<10;I++)
{
  text = "Line" + Convert.ToString(i);
//在循环中未初始化，在退出循环的时候会丢失值，再引用就出错。
  Console.WriteLine("{0},text);
}
Console.WriteLine("Last txet output in loop:{0},text);
//出错。改正方法是在循环外初始化：string text="";

class A
{
  public static int x;//静态变量,存在期从类装载直到该程序结束。
  int y;//非静态变量，或实例变量,从类实例创建到实例空间释放。
  
  /*v[0]是数组元素，a是值参数，b是引用参数，c是输出参数 */
  void F(int[] v,int a,ref int b,out int c){
    int i = 1;//局部变量，不会被初始化
    c = a + b++;//
  }
}

　　enum 枚举名:枚举值类型（默认是int，默认赋值0,1,2...）
　　｛
　　　枚举值1=...,
　　　枚举值2=...,
　　　枚举值3,//不赋值的话，默认为最后一个明确具体值的值+1
　　　...
　　｝
　　枚举名 变量名＝枚举名.枚举值

namespace Ch05Ex02
{
  enum orientation:byte
  {
    north=1,
    south=2,
    east=3,
    west=4
  }
///Class1's Desciption
class Class1
  {
  static void Main(string［］ args)
    {
        byte directionByte;
        string directionString;
        orientation myDirection = orientation.north;
        Console.WriteLine("mydirection = {0}", myDirection);
        directionByte = (byte)myDirection;
//因为enum存得下byte,所以理论上可以正确地反过来转换，但逻辑上不一定正确。
myDirection = (orientation)myByte;
        directionString = Convert.ToString(myDirection);
//等价命令是directionString = myDirection.ToString();
//因为不单是把枚举变量值转存到string变量中，所以不能用string(mydirection);
//反向转换命令
是orientation myDirection = (orientation)Enum.Parse(typeof(orientation),myString);
但由于enum不一定存得下string，所以可能出错。如myString赋值为North，
就不能映射到orientation中的north，出错。
        Console.WriteLine("byte equivalent = {0}", directionByte);
        Console.WriteLine("string equivalent = {0}", directionString);
    }
  }
}

　　struct 结构名:
　　｛
　　　访问方式1 变量类型1 变量名1;//访问方式public/private
　　　访问方式2 变量类型2 变量名2;　　
　　　...
　　｝
　　结构名 结构变量名;
　　结构变量名.枚举值=...;

Ａ，For循环到.Length
for(i=0,i<friendNames.Length,i++)
{
  Console.WriteLine(friendNames［i］);
}
Ｂ，Foreach进行只读访问
foreach(string listName in friendNames) 
{
  Console.WriteLine(listName);
}

string myString = "I have a dream.";
char myChar = myString［2］;//把string变量当作只读的char数组使用，不能改写myString［2］
char［］ myChars = myString.ToCharArray();

char［］separator = ｛' '｝;//设定分隔符
string［］ myWords =myString.Split(separator);//分隔成数组
Console.WriteLine("myString have {0} chars",myString.Length);
myString=myString.ToLower();//转小写
myString=myString.ToUpper();//转大写
myString=myString.Trim();//删前后空格
myString=myString.TrimStart();//删前空格
myString=myString.TrimEnd();//删后空格
myString=myString.PadLeft(位数);//前补空格到指定位数
myString=myString.PadRight(位数);//后补空格到指定位数
myString=myString.PadLeft(位数,字符);//前补指定字符到指定位数

char［］ trimChars = ｛"e","#","*"｝;
myString = myString.trim(trimChars);//删指定字符

算术运算符：前缀的++和-- ,前缀一元的+和- 乘 * 除 / 求余 % 加 + 减 - 

位移运算符：<<,>>

比较运算符：小于 < 大于 > 小于等于 <= 大于等于 >=

比较运算符：==,!=

逻辑运算符：&

逻辑运算符：^

逻辑运算符：|

逻辑运算符：&&

逻辑运算符：||

比较运算符：等于 = *= /= %= += -= <<= >>= &= ^=  |= 

后缀的++和--

namespace 空间名称
　{
　　　　using 空间名称2.代码2;//之后就能在代码1处直接引用代码2
　　　　代码1;
　　　　namespace 空间名称2
　　　　{
　　　　代码2;
　　　　}
　}

　　If （条件1）
　　　　代码1;
　　Else
　　　　代码2;
　　If （条件1）
　　｛｝
　　Else
　　｛｝

　　Switch (条件)
　　　{
　　　　Case 结果1:
　　　　代码1;
　　　　break;
　　　　Case 结果2:
　　　　代码2;
　　　　break;
　　　　Case 结果3:
　　　　代码3;
　　　　goto Case  结果2;//此时Case..相当于一个Label
　　　　Case 结果4:
　　　　代码4;
　　　　Return;
　　　　Case 结果5:
　　　　Case 结果6:
　　　　Case 结果7:
　　　　代码567;//只要满足上面三个Case之一就执行。
　　　　break;
　　　　...
　　　　Default:
　　　　代码;
　　　　break;
　　　｝
    

　　Do 
　　{...}
　　While(条件);//分号不可少

　　While(条件)
　　{...}

　　For (变量;条件;操作)//可以在此时声明变量，但作用域就仅限于循环内了。
　　{...
　　Break;//跳出整个循环
　　Return;
　　Continue;//中止当前循环,继续下一个循环
　　Goto 标签;//禁止从循环外部用goto跳入循环内部
　　}

Ａ，函数定义：
    static 返回值类型/void 函数名(参数类型1 参数1,参数类型2 参数2,...)
    {
      ...
      return 返回值;//return必须在函数结束前被处理，不能跳过
      //return ;//当用于void时用不带返回值的return来中止函数。
    }

 static int sumVals(params int[] vals)
  {
    int sum = 0;
    foreach(int val in vals)
    {
      sum+=val;
    }
    return sum;
  }

  static void Main(string[] args)
  {
    int sum = sumVals(1,5,2,9,8);
    Console.WriteLine("Summed Values = {0}",sum);
  }

Ｃ，值传递参数/引用传递参数/out输出参数

static void showDouble(ref int val)//引用传递参数
{
  val*=2;
  Console.WriteLie("val doubled = {0}",val);
}
static void showDouble2(int val)//值传递参数
{
  val*=2;
  Console.WriteLine("val doubled = {0}",val);
}
static void showDouble3(int val,out int valIndex)//out输出参数
{
  val*=2;
  valIndex++;
  Console.WriteLine("val doubled = {0}",val);
}

int myNmuber = 5;
showDouble(ref myNumber);
//引用传递参数,会改变myNumber值，所以要求myNumber必须不是常量或者未初始化的变量。
showDouble2(myNumber);//值传递参数,不会改变myNumber值

int valindex;//out输出参数，不用初始化，初始化了也会在函数开始执行时丢失值。
showDouble3(myNumber,out valIndex);

static void Main()
static void Main(string［］ args)//args是函数命令行参数
static int Main()//返回一个表示函数终止状态的int值
static int Main(string［］ args)//返回一个表示函数终止状态的int值

class 类名
{
  //类成员
}
internal/public

sealed/abstract

interface IMyInterface
{
  //接口成员
}