C#编程总结

以下为对C#的关键字、语法、高级应用所做的个别阐述与学习记录，当然在MSDN中都有详细的说明！

1、关键字params
主要实现：动态的可变参数
注意：params 关键字之后不允许任何其他参数
            方法声明中只允许一个 params
DEMO：

public   static   void  UseParams( params   int [] list) 
... { 
for ( int i = 0 ; i < list.Length ; i++ ) 
Console.WriteLine(list[i]); 
Console.WriteLine(); 
}  

int [] myarray  =   new   int [ 3 ]  ... {10,11,12} ; 
UseParams(myarray); 

输出：10  11  12

2、关键字out ref
主要实现：通俗一些就是传递out ref类型的变量给特定函数后，函数中对该变量所做的任何修改都会反应到变量上，这和C++里的引用类型所实现的一致，改变在内存空间的值，而该内存空间的地址不改变。
out：在返回多个参数时非常有用，不必初始化变量，返回之前必须为 out 参数赋值
ref：需初始化变量
当然ref 和 out可以传递数组
注意：
以下声明有效：
public void MyMethod(int i) {i = 10;}
public void MyMethod(out int i) {i = 10;}
以下声明无效：无法定义仅在 ref 和 out 方面不同的重载
public void MyMethod(out int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}

DEMO：
public static void TestRef(ref char i)
{
// The value of i will be changed in the calling method
i = 'b';
}

public static void TestNoRef(char i)
{
// The value of i will be unchanged in the calling method
i = 'c';
}

char i = 'a'; // variable must be initialized
TestRef(ref i); // the arg must be passed as ref
Console.WriteLine(i);
TestNoRef(i);
Console.WriteLine(i);

输出
b
b

3、== 和 Equal
==：恒等判断
Equal：恒等、比较两个引用类型是否引用同一对象，按位判断相等
主要区别：多态。运算符被重载而不是被重写，这意味着除非编译器知道调用更为具体的版本，否则它只是调用恒等版本

        // Create two equal but distinct strings
        string a = new string(new char[] {'h', 'e', 'l', 'l', 'o'});
        string b = new string(new char[] {'h', 'e', 'l', 'l', 'o'});
        Console.WriteLine (a==b);
        Console.WriteLine (a.Equals(b));
        // Now let's see what happens with the same tests but
        // with variables of type object
        object c = a;
        object d = b;
        Console.WriteLine (c==d);//对象的==比较
        Console.WriteLine (c.Equals(d));

True
True
False
True

 4、其他
调用委托之前，需要执行 null 测试判断

=====================================高级应用=====================================

委托、泛型、反射等高级性的概念知识一直被抬的很高、很火，也一直被广泛的应用，在Coding、实现需求的过程中，这些的确显得大有益处，既然都是概念性的东西，掌握起来其实并不难，“难”就难在我们愿不愿意花上几分钟去看看：）

第一、委托
一、基本应用
简述：当A和B同步，A需要从B的处理状态中获得命令或受B对象的控制（B是一个整体，并不属于A，B的动作可以作为A动作的一部分
域：静态、非静态、可控、安全
应用：
1、声明一个delegate对象（与传递的方法返回值应相同）       

public   delegate   void  MyDelegate( string  name);

2、创建delegate对象，将函数作为参数传入

      MyDelegate md  =   new  MyDelegate(A);
      MyDelegate md  =   new  MyDelegate(B);

3、在要实现异步调用的地方，通过上一步创建的对象来调用方法
      md("sam1111");
        // 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型

         public   static   void  A( string  name)
         ... {
                  Console.WriteLine("Hello, ", name);
        }
         public   static   void  B( string  name)
         ... {
                  Console.WriteLine("Hello, ", name);
        }

第二、委托事件
一、
(1)定义delegate对象类型

      MyDelegate md  =   new  MyDelegate(A);
      MyDelegate md  =   new  MyDelegate(B);

 

public   delegate   void  MyEventHandler( object  sender, System.EventArgs e);

(2)
定义事件参数类，从System.EventArgs类派生。如果事件不带参数，这里可以省略
(3)定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型

                 public    void  MyEventFunc( object  sender, System.EventArgs e)
                 ... {
                           Console.WriteLine("My event is ok!");
                }

(4)用event关键字定义事件对象，它同时也是一个delegate对象

private   event  MyEventHandler myevent;

(5)用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。

this .myevent  +=   new  MyEventHandler(myecls.MyEventFunc);

(6)在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName

    protected   void  OnMyEvent(System.EventArgs e)
       ... {
               if(myevent != null)
                       myevent(this, e);
      }

(7)在适当的地方调用事件触发方法触发事件

               EventArgs e  =   new  EventArgs();
               OnMyEvent(e);

2、泛型

3、反射