前文：
一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序 至少有一个 带有 Main 方法的 类。
要使用一个方法，需要进行 定义 方法和 调用 方法。
定义方法
当定义一个方法时，从根本上说是在声明它的结构的元素。在 C# 中，定义方法的语法如下：
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}
- Access Specifier：访问修饰符，这个决定了变量或方法对于另一个类的可见性。
- Return type：返回类型，一个方法可以返回一个值。返回类型是方法返回的值的数据类型。如果方法不返回任何值，则返回类型为 void。
- Method name：方法名称，是一个唯一的标识符，且是大小写敏感的。它不能与类中声明的其他标识符相同。
- Parameter list：参数列表，使用圆括号括起来，该参数是用来传递和接收方法的数据。参数列表是指方法的参数类型、顺序和数量。参数是可选的，也就是说，一个方法可能不包含参数。
- Method body：方法主体，包含了完成任务所需的指令集。
下面的代码片段显示一个函数 FindMax ，它接受两个整数值，并返回两个中的较大值。它有 public 访问修饰符，所以它可以使用类的实例从类的外部进行访问：
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}
调用方法
可以使用方法名调用方法：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine($"最大值是： {ret}");
Console.ReadLine();
}
}
}
执行结果：
最大值是： 200
也可以使用类的实例从另一个类中调用其他类的公有方法，例如，方法 FindMax 属于 NumberManipulator 类，您可以从另一个类 Test 中调用它：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
}
class Test
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine($"最大值是： {ret}");
Console.ReadLine();
}
}
}
执行结果：
最大值是： 200
关于静态方法和非静态方法的调用，详见：C++和C#调用不同目录其他文件中的函数或方法
递归调用
简单理解来说就是套娃，方法自己调用自己，例如：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* 局部变量定义 */
int result;
if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
//调用 factorial 方法
Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
Console.ReadLine();
}
}
}
输出结果：
6 的阶乘是： 720
7 的阶乘是： 5040
8 的阶乘是： 40320
参数传递
当调用带有参数的方法时，需要向方法传递参数，有三种向方法传递参数的方式：
- 值参数： 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。
- 引用参数： 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。
- 输出参数： 这种方式可以返回多个值。
值参数
这是参数传递的默认方式，在这种方式下，当调用一个方法时，会为每个值参数创建一个新的存储位置。实际参数的值会复制给形参，实参和形参使用的是两个不同内存中的值。所以，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全，示例：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void Swap(int x, int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine($"在交换之前，a 的值： {a}");
Console.WriteLine($"在交换之前，b 的值： {b}");
/* 调用函数来交换值 */
n.Swap(a, b);
Console.WriteLine($"在交换之后，a 的值： {a}");
Console.WriteLine($"在交换之后，b 的值： {b}");
Console.ReadLine();
}
}
}
输出：
结果表明，即使在函数内改变了值，值也没有发生任何的变化。
不要被概念搞迷糊了，函数内部交换之后的x、y变量，即使值已经发生了变化，但是没有返回和调用，所以显示的还是原本刚定义的初始值。
引用参数
引用参数是一个对变量的 内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。在 C# 中，使用 ref 关键字声明引用参数，类似于C++中指针的概念。
示例：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void Swap(ref int x, ref int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine($"在交换之前，a 的值： {a}");
Console.WriteLine($"在交换之前，b 的值： {b}");
/* 调用函数来交换值 */
n.Swap(ref a, ref b);
Console.WriteLine($"在交换之后，a 的值： {a}");
Console.WriteLine($"在交换之后，b 的值： {b}");
Console.ReadLine();
}
}
}
执行结果：
结果表明，swap 函数内的值改变了，且这个改变可以在 Main 函数中反映出来。
输出参数
return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void GetValue(out int x )
{
int temp = 5;
x = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
Console.WriteLine($"在方法调用之前，a 的值： {a}");
/* 调用函数来获取值 */
n.GetValue(out a);
Console.WriteLine($"在方法调用之后，a 的值： {a}");
Console.ReadLine();
}
}
}
输出结果：
在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5
提供给输出参数的变量不需要赋值，当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用，例如：
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void GetValues(out int x, out int y )
{
Console.WriteLine("请输入第一个值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第二个值： ");
y = Convert.ToInt32(Console.ReadLine());
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a , b;
/* 调用函数来获取值 */
n.GetValues(out a, out b);
Console.WriteLine($"在方法调用之后，a 的值： {a}");
Console.WriteLine($"在方法调用之后，b 的值： {b}");
Console.ReadLine();
}
}
}
输入输出结果：
请输入第一个值：
7
请输入第二个值：
8
在方法调用之后，a 的值： 7
在方法调用之后，b 的值： 8
可空类型
单双问号
? 单问号用于对 int 、double 、bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型是 Nullable 类型的。
int? i = 3;
// 等同于：
Nullable<int> i = new Nullable<int>(3);
// 还有：
int a; //默认值0
int? b; //默认值null
?? 双问号用于判断一个变量在为 null 的时候返回一个指定的值，如果左边的表达式为 null ，则返回右边的值；否则返回左边的值。例如：
int? number = null;
int result = number ?? 10; // 如果 number 为 null，则 result = 10
Console.WriteLine(result); // 输出：10
// 或者：
string name = null;
string displayName = name ?? "Guest"; // 如果 name 为 null，则 displayName = "Guest"
Console.WriteLine(displayName); // 输出：Guest
详见： C#中的可空类型和问号
可空类型
C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。
例如，Nullable<Int32> ，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。类似的，Nullable<bool> 变量可以被赋值为 true 或 false 或 null 。
在处理数据库和其他包含可能未赋值的元素的数据类型时，将 null 赋值给数值类型或布尔型的功能特别有用。例如，数据库中的布尔型字段可以存储值 true 或 false，或者，该字段也可以未定义。
示例：
using System;
namespace CalculatorApplication
{
class NullablesAtShow
{
static void Main(string[] args)
{
int? num1 = null;
int? num2 = 45;
double? num3 = new double?();
double? num4 = 3.14157;
bool? boolval = new bool?();
// 显示值
Console.WriteLine($"显示可空类型的值： {num1}, {num2}, {num3}, {num4}");
Console.WriteLine($"一个可空的布尔值： {boolval}");
Console.ReadLine();
}
}
}
执行结果：
双问号的作用示例：
using System;
namespace CalculatorApplication
{
class NullablesAtShow
{
static void Main(string[] args)
{
double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34; // num1 如果为空值则返回 5.34
Console.WriteLine($"num3 的值： {num3}");
num3 = num2 ?? 5.34;
Console.WriteLine($"num3 的值： {num3}");
Console.ReadLine();
}
}
}
输出结果：
num3 的值： 5.34
num3 的值： 3.14157