C#学习心路历程

这里只记录C#的特色地方，想来本科专攻c++跟图形编程，真心没想到半路杀出来个unity还特么用了c#，所以嘛，最近恶补这方面的东西，把跟c++相似的地方看看就好，这里把c#的好东东都记录下，有一些还挺有逼格的说，希望能有幸成为高手！

1、params关键字

本关键字在于可变长参数的利用，比如

static void countNumbers(params int vals) {

foreach(val in vals) {

Console.write("current number is {0}" ,  val);

}

}

调用的时候可以传入任意数量的数字，比如countNumbers(1,2.3);

2、传入引用

此处需要加ref

static void doIt(ref int val ) {

val++;

}

在这个地方，传入一个const类型的变量就会变成非法的，因为const无法被改动，未赋值变量也不允许传入，个人猜测应该是c#的内存机制，没有用到或者复制的变量是不会去分配内存的。

传入形式：doIt(ref param);

3、out参数，传出引用

这个参数代表传入一个参数之后，会在函数里做修改，然后传出，与ref相似，但是传入必须是一个未初始化的变量，否则如果已初始化，本变量在传入函数时候会被清理为空

static void func(out int a);

4、参数作用域神奇版

int m;

for(int i = 0;i < 9;i++) {

m  = 1 + i;

}

这里在循环过后，是无法看到m的值的，因为m的内存是在循环中分配的，再循环中分配的内存，到了循环之外就会释放掉，就好比局部变量，这也是c#做出的很好的优化，所以需要有一个标准：变量在声明的时候就必须初始化！

5、委托

其实委托就是一种函数指针，声明形式如下

delegate double ProcessDelegate(int a);

赋值跟执行的时候如此：

static   double   Mult ( int   a ) {

             Console . WriteLine  ( " {0} "  ,  a );

             return   0.0f ;

        }

ProcessDelegate   process  =  new   ProcessDelegate  ( Mult );

process  ( 1 );

这个可以用来进行做监听者模式

6、面向对象

继承的时候，基类必须在接口类前面

public class Myclass:base,InterClass {

}

接口定义：

public interface myinter {

}

类型构造函数，如果声明为private的构造函数，可以用来作单例模式，防止生成新对象

对于析构函数，会先调用本类析构，之后调用父类析构，最后调用object的Finalize函数进行清理

类内变量定义：

1、readonly关键字 public readonly  int MyInt = 17；这样限制只读

2、virtual 方法可以重写

3、abstract 方法是虚方法，子类中必须实现

4、override 方法重写了一个基类的方法

    public virtual void doSth() {

         }

     }

      public  class MyClass:MyBaseClass {

          public  override  void doSth() {

         }

     }

如果想让重写到此为止，即导致MyClass的子类无法重写doSth的话，就需要加入sealed关键字

public   override  sealed void   doSth () {

     }

5、访问器

private   int   myInt ;

         public   int   MyInt  {

             get  {

                 return   myInt ;

            }

             set {

                myInt =  value;

            }

        }

  6、隐藏跟重载

 隐藏即BaseClass中由函数A，

public   class   BaseClass  {

         public   void   A (){

         }

     }

      public  class BaseDerivedClass:BaseClass {

         new  public  void A(){

    }

     }

这样的形势下，无法进行多态，即无法用父类指针指向子类对象的方法来实现调用子类函数。但是子类自己可以调到

其中new的含义就是指重写，否则会报警告。

   在这里插一嘴：

   a、重写：即在函数多态性中应用，子类重写父类的虚函数

   b、重载：利用函数的传入参数不同而不同

   c、隐藏：在子类中重新写一遍父类的方法，用new来声明，不具有多态性

不管是隐藏还是重写，在子类中都可以先调用父类的对应函数，然后在写自己的内容，就好比cocos2d-x中的onEnter，可以先调用父类的onEnter，再写自己的

public   class   BaseClass  {

         public   void   A (){

              // do

         }

   }

     public  class BaseDerivedClass:BaseClass {

         new  public  void A(){

             base.A ();

             // dosth   new

         }

     }