总结

1、C#区分大小写的语言
2、命名空间（命名空间是可以嵌套的）
namespace
using
3、Main函数，参数与返回值（返回值为 viod或者int，参数为string[]或者没有参数）
程序的入口点
通过创建快键方式来给程序送参数，也可以通过另个的应用程序调用。
用批处理命令获取返回值：“@echo %ERRORLEVEL%”把这个命令用txt文档保存，并把扩展名改成bat，然后在vs命令行中获得结果。
4、C#中的注释
//单行注释
/* */多行注释
///xml注释
5、值类型：基于值类型的变量直接包含值。将一个值类型变量赋给另一个值类型变量时，将复制包含的值。
           所有的值类型均隐式派生自 System. ValueType。
           每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。
   值类型：简单类型（sbyte, short, int, long，byte, ushort, uint, ulong，char，float, double，decimal，bool）、枚举类型           （enum E {...} ）、结构类型（struct S {...} ）
   引用类型：引用类型的变量又称为对象，可存储对实际数据的引用。
   引用类型：类类型（class C {...} ）、接口类型（interface I {...}）、Unicode字符串（string）、数组类型（一维和多维数组   ，例如int[]和int[,]）、委托类型（delegate T D(...) ）
6、匿名类型：var v = new { Amount = 108, Message = "Hello" };v.Amount,v.Message;
7、Parse：类型.Parse(string)
          int  i=int.Parse(“123”);
   Convert.To类型：强类型转换
          int i=Convert.ToInt32(“123”);
8、条件语句：
if（条件）
{
}
else
{
}

switch(变量)
{
 case 常量1：
      break;
 case 常量2：
      break;
 default:
      break;
}
9、循环语句：
while
do……while
for
foreach(  in  )
10、跳转语句：
break
跳出全部循环
Continue
跳出本次循环
goto
static void Main(string[] args)
   {
       goto Mark;
       Console.WriteLine("第一行");
     Mark:
       Console.WriteLine("第二行");
   }
Return
返回
Throw
抛出异常
11、异常处理语句：
try……catch
try……cattch……finally
try……finally
12、结构的特点：
结构是值类型，而类是引用类型。
与类不同，结构的实例化可以不使用 new 运算符。
结构可以声明构造函数，但它们必须带参数。
一个结构不能从另一个结构或类继承，而且不能作为一个类的基。所有结构都直接继承自 System.ValueType，后者继承自 System.Object。
结构可以实现接口。
结构可用作可为 null 的类型，因而可向其赋 null 值。
结构的访问修饰符可以是public,internal，默认修饰符为internal.
结构可包含构造函数（有参），常量，字段，方法，属性，索引器，事件和嵌套类型。
成员的访问修饰符可是private,public但不可以是protected
结构的实例化有两种方式：
 struct MyStr
    {
        public int i; 
    }

MyStr ms1=new MyStr();

MyStr ms2;
ms2.i=10;
13、数组：Array MyArr = Array.CreateInstance(typeof(int), 5);MyArr.SetValue(1, 0);//赋值
    利用数组排序：Array.Sort(myarr);然后再foreach遍历。倒序：Array.Sort(myarr);Array.Reverse(myarr)(反转);然后再foreach    遍历。
    一维数组的定义：
    1、int[] arr = new int[2] { 1, 2 };
    2、int[] arr = new int[] { 1, 2 };
    3、int[] arr = new int[2];
       arr[0] = 1;
       arr[1] = 2;
    4、int[] arr = { 1, 2 };
14、二维和多维数组的定义、初始化、遍历

            int[,] arr = { { 1, 2 }, { 3, 4 } };

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    Console.WriteLine(arr[i,j]);
                }
            }

            foreach (var i in arr)
            {
                Console.WriteLine(i);
            }
15、集合：
            ArrayList al = new ArrayList();
            al.Add(1);
            al.Add("2");
            foreach (object o in al)
            {
                Console.WriteLine("类型：{0}",o.GetType().Name);
                Console.WriteLine("值为：{0}",o);
            }
            Console.WriteLine("======================");
            for (int i = 0; i < al.Count; i++)
            {
                Console.WriteLine("类型：{0}",al[i].GetType ().Name);
                Console.WriteLine("值为：{0}",al[i]);
            }
16、泛型：
         List<T> 类是 ArrayList 类的泛型等效类。该类使用大小可按需动态增加的数组实现 IList<T> 泛型接口。

         T是一个类型参数，标明列表中元素的准确类型，而不是ArrayList中的object中的类型。类型可以是值类型也可以是引用类型         。

            List<int> mylist = new List<int>();
            mylist.Add(1);
            mylist.Add(2);
            mylist.Add(3);
            mylist.Add(4);
            mylist.Add(5);
            foreach (int i in mylist)
            {
                Console.WriteLine(i);
            }
17、类的定义：
         [访问修饰符] class <类名>
         {
          // 类的主体
         }
18、方法：是包含一系列语句的代码块。作用是完成一定的功能。方法是通过指定修饰符、返回值类型、方法名称和任何方法参数在类或结构中声明的。这些部分统称为方法的“签名”。 方法参数括在括号中，并用逗号隔开。空括号表示方法不需要参数。在定义方法时的参数叫“形式参数（形参）”，在调用方法时的参数叫“实际参数（实参）”。
19、分布方法：  partial 关键字指示可在命名空间中定义该类、结构或接口的其他部分。所有部分都必须使用 partial 关键字。在编译时，各个部分都必须可用来形成最终的类型。各个部分必须具有相同的可访问性，如 public、private 等。
注意事项：
分部方法声明必须以上下文关键字 partial 开头，并且方法必须返回 void。
分部方法可以有 ref 参数，但不能有 out 参数。
分部方法为隐式 private 方法，因此不能为 virtual 方法。
分部方法不能为 extern 方法，因为主体的存在确定了方法是在定义还是在实现。
分部方法可以有 static 和 unsafe 修饰符。
分部方法可以为泛型的。约束将放在定义分部方法声明上，但也可以选择重复放在实现声明上。参数和类型参数名称在实现声明和定义声明中不必相同。
不能将委托转换为分部方法。
20、访问修饰符：
public：访问不受限制。
protected：访问仅限于包含类或从包含类派生的类型。
Internal：访问仅限于当前程序集。
protected internal：访问仅限于当前程序集或从包含类派生的类型。
private：访问仅限于包含类型。
21、构造函数与类名相同，无返回值类型。构造函数：访问修饰符类名。析构函数：~类名
    析构函数需要注意的：
    不能在结构中定义析构函数。只能对类使用析构函数。
    一个类只能有一个析构函数。
    无法继承或重载析构函数。
    无法调用析构函数。它们是被自动调用的。    
    析构函数既没有修饰符，也没有参数。
22、索引器：
     索引器允许类或结构的实例就像数组一样进行索引。索引器类似于属性，不同之处在于它们的访问器采用参数。
     使用索引器可以用类似于数组的方式为对象建立索引。
     get 访问器返回值。set 访问器分配值。
     this 关键字用于定义索引器。
     value 关键字用于定义由 set 索引器分配的值。
     索引器不必根据整数值进行索引，由您决定如何定义特定的查找机制。
     索引器可被重载。
     索引器可以有多个形参，例如当访问二维数组时。    
     class MyCol
    {
        string[] StrArr = new string[1];
        public string this[int i]
        {
            get
            {
                return StrArr[i];
            }
            set
            {
                if (value.Length < 5)
                {
                    StrArr[i] = value;
                }
            }
        }
    }
 

    class Program
    {
        static void Main(string[] args)
        {
            MyCol mc = new MyCol();
            mc[0] = "aaa";
            Console.WriteLine(mc[0]);
        }
    }

23、委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的调用可以像其他任何方法一样，具有参数和返回值。
与委托的签名（由返回类型和参数组成）匹配的任何可访问类或结构中的任何方法都可以分配给该委托。方法可以是静态方法，也可以是实例方法。这样就可以通过编程方式来更改方法调用，还可以向现有类中插入新代码。只要知道委托的签名，便可以分配自己的委托方法。
委托的定义：
delegate void Dele(int i); 
定义方法：
 public void Method(int i)
        {
            Console.WriteLine("参数为:{0}",i);
        }
关联委托和方法：
Program pro = new Program();
Dele del = new Dele(pro.Method);
Dele del1=pro.Method;
del1(100);
del(100);
24、委托的协变
 class Phone
    {
    }
    class Mobile : Phone
    {
    }
    delegate Phone PhoneDele();
    class Program
    {
        static void Main(string[] args)
        {
            Program pro = new Program();
            PhoneDele pd1 = pro.GetPhone;
            PhoneDele pd2 = pro.GetMobile;//委托类型的协变
        }
        public Phone GetPhone()
        {
            return null;
        }
        public Mobile GetMobile()
        {
            return null;
        }
    }
25、委托的逆变
 class Phone
    {    }
    class Mobile : Phone
    {    }
    delegate void PhoneDele(Mobile  pho);
    class Program
    {
        static void Main(string[] args)
        {
            Program pro = new Program();
            PhoneDele pd1 = pro.SetPhone;//委托类型的逆变
            PhoneDele pd2 = pro.SetMobile;
        }
        public void SetPhone(Phone pho)
        {     }
        public void SetMobile(Mobile mob)
        {  }
    }
26、逆变是从参数来说的：委托的参数要小，方法的参数要大。协变是从返回值类型来说的：委托的返回值要大，方法的返回值要小。
27、事件：类或对象可以通过事件向其他类或对象通知发生的相关事情。发送（或引发）事件的类称为“发行者”，接收（或处理）事件    的类称为“订户”。
    事件具有以下特点：
    发行者确定何时引发事件，订户确定执行何种操作来响应该事件。
    一个事件可以有多个订户。一个订户可处理来自多个发行者的多个事件。
    没有订户的事件永远不会被调用。
    事件通常用于通知用户操作，例如，图形用户界面中的按钮单击或菜单选择操作。
    如果一个事件有多个订户，当引发该事件时，会同步调用多个事件处理程序。要异步调用事件，请参见使用异步方式调用同步方法。
    可以利用事件同步线程。
    在 .NET Framework 类库中，事件是基于 EventHandler 委托和 EventArgs 基类的。

    //定义委托
    delegate void MyDele(string str);
    class Program
    {    //定义事件
        event MyDele MyEvent;
        static void Main(string[] args)
        {
            Program pro = new Program();
            //订阅方法
            pro.MyEvent += new MyDele(pro.MyMethod);
            pro.MyMethod("参数1"); 
        } 
        //定义委托方法
        public void MyMethod(string str)
        {
            Console.WriteLine("方法参数为：" + str);
        }
    }
28、密封类：可以将类声明为密封类。方法是在类定义中将关键字 sealed 置于关键字 class 的前面。密封类不能用作基类。因此，它也不能是抽象类。密封类主要用于防止派生。由于密封类从不用作基类，所以有些运行时优化可以使对密封类成员的调用略快。
29、静态类：静态类和类成员用于创建无需创建类的实例就能够访问的数据和函数。
    静态类的主要功能如下：
    它们仅包含静态成员。
    它们不能被实例化。
    它们是密封的。
    它们不能包含实例构造函数。
    静态方法可以被重载，但不能被重写。
30、抽象类：使用 abstract 关键字可以创建仅用于继承用途的类和类成员，即定义派生的非抽象类的功能。
    public abstract class A
    {
    }  
    抽象类不能实例化。抽象类的用途是提供多个派生类可共享的基类的公共定义。例如，类库可以定义一个作为其多个函数的参数的抽     象类，并要求程序员使用该库通过创建派生类来提供自己的类实现。抽象类也可以定义抽象方法。方法是将关键字 abstract 添加到     方法的返回类型的前面。
31、接口是使用 interface 关键字定义的。
    interface IMyInterface 
    { 
    }
    接口具有下列属性：
    接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
    不能直接实例化接口。
    接口可以包含事件、索引器、方法和属性。
    接口不包含方法的实现。
    类和结构可从多个接口继承。
    接口自身可从多个接口继承。
32、继承：类可以从其他类中继承。这是通过以下方式实现的：在声明类时，在类名称后放置一个冒号，然后在冒号后指定要从中继承的类（即基类）。
public class A
 { 
   public void MyMethod() 
   { 
   } 
} 
public class B : A
{
} 
新类（即派生类）将获取基类的所有非私有数据和行为以及新类为自己定义的所有其他数据或行为。因此，新类具有两个有效类型：新类的类型和它继承的类的类型。
33、运算符重载：
    public struct Complex
  {
    public int real;
    public int imaginary;
    public Complex(int real, int imaginary) 
   {
        this.real = real;
        this.imaginary = imaginary;
    }
    public static Complex operator +(Complex c1, Complex c2)
    {
        return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
    }
    public override string ToString()
    {
        return (System.String.Format("{0} + {1}i", real, imaginary));
    }
  }

  class TestComplex
{
    static void Main()
    {
        Complex num1 = new Complex(2, 3);
        Complex num2 = new Complex(3, 4);
        Complex sum = num1 + num2;
        Console.WriteLine("First complex number:  {0}", num1);
        Console.WriteLine("Second complex number: {0}", num2);
        Console.WriteLine("The sum of the two numbers: {0}", sum);
    }
}