值与引用参数ref

声明时不带修饰符的形参是值形参，初始值来自该方法调用所提供的相应实参。

  1. static void Main(string[] args)
  2. {
  3.     int i = 100;
  4.     Test(i);
  5.     Console.WriteLine(i);//i还是100，值传递没有被改变
  7.     int[] a = new int[] { 1, 2 };
  8.     Test2(a);
  9.     Console.WriteLine(a[0]+"   "+a[1]);//88  99这是引用传递，值被改变了，传进去的只是a的地址
  11.     int t = 111;
  12.     Test3(ref t);
  13.     Console.WriteLine(t);//222，实参与形参都加关键字ref，就变成了引用传递，传的是值的地址
  14. }
  15. static void Test(int i)
  16. {
  17.     i = 300;
  18. }
  19. static void Test2(int[] a)
  20. {
  21.     a[0] = 88;
  22.     a[1] = 99;
  23. }
  24. static void Test3(ref int t)
  25. {
  26.     t = 222;
  27. }

输出参数out

获得除了返回值以外的额外输出。和传进来的实参指向同一个内存的位置，是引用传递。
这样，一个函数可以变相的有多个返回值。

和ref一样，语义上不一样，ref是为了改变，out是为了输出

  1. static void Main(string[] args)
  2. {
  3.     int a = 100;
  4.     int b = 0;
  5.     bool bo = Test(a,out b);
  6.     Console.WriteLine(b);//200
  8.     //声明一些空变量用来接收out参数的返回值
  9.     int aa = 0;
  10.     string bb = "";
  11.     double cc = 0;
  12.     bool dd = Test(out aa, out bb, out cc);
  13.     //变相获得了4个返回值
  14.     Console.WriteLine(aa);
  15.     Console.WriteLine(bb);
  16.     Console.WriteLine(cc);
  17.     Console.WriteLine(dd);
  18. }
  19. static bool Test(int i, out int b)
  20. {
  21.     //方法体里面必须为out参数赋值
  22.     b = i * 2;
  23.     return true;
  24. }
  25. static bool Test(out int aa,out string bb,out double cc)
  26. {
  27.     aa =  1234;
  28.     bb = "假设aa，bb,cc都是经过了不止这么弱智的计算";
  29.     cc = 123.456;
  30.     return true;
  31. }

数组参数params

必须是形参列表的最后一个，由params修饰

  1. static void Main(string[] args)
  2. {
  3.     int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9);
  4.     Console.WriteLine(sum);
  5. }
  6. static int getSum(params int[] i)
  7. {
  8.     int sum = 0;
  9.     foreach(int ii in i)
  10.     {
  11.         sum += ii;
  12.     }
  13.     return sum;
  14. }

具名参数

  1. 可以提高可读性
  2. 参数顺序不受参数列表约束 ```csharp static void Main(string[] args) { Test(“张三”, 12);//不具名 Test( age: 21,name: “李四”);//具名 } static void Test(string name,int age) {

}

  1. <a name="axxhz"></a>
  2. # 可选参数
  3. ```csharp
  4. static void Main(string[] args)
  5. {
  6.     Test("张三");//age在声明时有了默认初始值，可以不填
  7. }
  8. static void Test(string name,int age = 12)
  9. {
  11. }

扩展方法this

给一个类型对象添加一个方法，格外拓展。

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         int a = 100;//目前a没有我们想要的方法，我们想要给他加一个方法
  6.         //调用时 . 前面的 a就是第一个参数，括号里面写出了被this修饰的其他参数
  7.         Console.WriteLine(a.setInt(14));//1400
  8.     }
  10. }
  11. //创建一个静态的类，名字约定俗成，想要扩展的类名+Extension
  12. static class IntExtension
  13. {
  14.     //静态方法，第一个加上this修饰，a就是要加方法的那个东西，后面的就是正常参数
  15.     public static int setInt(this int a,int b)
  16.     {
  17.         return a * b;
  18.     }
  19. }