C#捷径编程笔记7

1.参数数组
    C#传递可变参数列表需要把参数列表的最后一个参数声明为数组类型,并在数组类型前加上params关键字.这样,如果这个方法被可变数量的参数调用,这些参数以数组的形式传入方法,就可以方便地迭代这个数组.这个数组类型可以是任意的合法类型.下面是个简单的例子:
   

using System;



namespace ConsoleApplication2

{

    class Program

    {

        static void Main(string[] args)

        {

            A(42);

            A(42, 43, 44);

            A(44, 56, 23, 234, 45, 123);

        }



        static void A(int val1, params int[] vals)

        {

            Console.WriteLine("val1:{0}", val1);

            foreach (int i in vals)

            {

                Console.WriteLine("vals[]:{0}", i);

            }

            Console.WriteLine();
        }
    }
}

这段代码的运行结果是:
val1:42

val1:42
vals[]:43
vals[]:44

val1:44
vals[]:56
vals[]:23
vals[]:234
vals[]:25
vals[]:123
如果注释掉12行,那么结果就变成下面这样:

vals[]:43
vals[]:44

vals[]:56
vals[]:23
vals[]:234
vals[]:45
vals[]:123

2.可选参数
    C#4.0中引入了可选参数,可选参数在C#中的工作方式与他们在C++中非常相似.在方法声明中,你可以在声明点给方法参数提供一个默认值.没有默认值的参数就被认为是必须的参数.此外,在方法声明中,必须参数不能跟在默认参数后面.比如函数可以这样定义:
int fun(string para1,int para2=0,int para3 = 0)
{}
    这里para2和para3为可选参数，实际上只是他们有默认值而已，要注意的是可选参数必须位于必选参数之后.可选参数就是可有可无的参数，无的话按默认值处理，一般和函数重载有关.

3.命名参数
    命名参数是C#4.0引入的新特性之一,是可选参数的补充.

static void Main
{
  TeamMember tm = new TeamMember(
                            isFullTime : true,
                            fullName : "Peter Gibbons");
}

    使用命名参数很简单,只要提供参数的名字,后面跟着分号和你想要赋给这个变量的值.当构造函数被调用的时候,其他的变量将使用默认值.事实上,也可以在上面的构造函数中给必须的变量只用命名参数.如果这样做,我可以完全交换参数列表中的参数的顺序.

4.virtual和abstract 的区别
    virtual和abstract都是用来修饰父类的,通过覆盖父类的定义,让子类重新定义.它们有一个共同点：如果用来修饰方法,前面必须添加public,要不然就会出现编译错误：虚拟方法或抽象方法是不能私有的.毕竟加上virtual或abstract就是让子类重新定义的,而private成员是不能被子类访问的. 但是它们的区别很大.(virtual是"虚拟的",abstract是"抽象的").
(1)virtual修饰的方法必须有实现(哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现.如对于virtual修饰的方法如果没有实现： 
       public class Test1
       {
           public virtual void fun1();
       }错误    2    “Test1.fun1()”必须声明主体,因为它未标记为 abstract、extern 或 partial  
    对于abstract修饰的方法如果有实现： 
       public abstract class Test2
       {
           public abstract void fun2() { }
       }错误    1    “Test2.fun2()”无法声明主体，因为它标记为 abstract  
(2)virtual可以被子类重写,而abstract必须被子类重写. 
   class BaseTest1
   {
      public virtual void fun() { }//必须有实现
   }
   class DeriveTest1:BaseTest1
   {
       //public override void fun() { }
   }编译不会出现错误，如果重写了virtual修饰的方法，前面必须添加override（这样就告诉了编译器你要重写虚拟方法），而且必须有实现，否则编译出错； 

   abstract class BaseTest2
   {
       public abstract void fun();
   }
   class DeriveTest2 : BaseTest2
   {
       //public override void fun();错误1: 重写时没有实现
       //public  void fun() { }  错误2：重写时没有添加override
       //override void fun() { }错误3：虚拟成员或者抽象成员不能是私有的（只要在父类中声明了虚拟成员或抽象成员，即便是继承的也要加上这个限制）
       public override void fun() { }//如果重写方法； 错误：“A.DeriveTest2”不实现继承的抽象成员“A.BaseTest2.fun()”     
   }
(3)如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。
(4)无法创建abstract类的实例，只能被继承无法实例化，比如: BaseTest2 base2 = new BaseTest2();将出现编译错误：抽象类或接口不能创建实例。
(5)C#中如果要在子类中重写方法，必须在父类方法前加virtual，在子类方法前添加override,这样就避免了程序员在子类中不小心重写了父类方法。
(6)abstract方法必须重写，virtual方法必须有实现(即便它是在abstract类中定义的方法). 
       abstract public class Test
       {
           //public virtual void Prinf();错误:virtual方法必须有实现
           public virtual void Prinf() //abstract类的virtual方法可以不重写；abstract方法必须重写。
           {
               Console.WriteLine("Abstract Printf...");
           } 
       }
       public class Class1 : Test
       {
           /*
           public override void Prinf() //派生类中不重写abstract类的virtual方法照样可以运行，不过调用派生类对象的Printf方法时，调用的是父类的。
           { 
               Console.WriteLine("Class One Override Printf...");
           }
            */
       }