1.前言
      c#教程C#不支持全局函数
      所有的函数必须在类内部声明
      无源文件和头文件之分
      所有的函数必须声明的时候被实现
int NotAllowed()      //错误，C#没有全局函数
{
            ...
}
sealed class Methods
{
    void Inline()
    { ...
    }
    void Error()
    { ...
    };                   //错误，函数不能有结尾分号
    int AlsoError();  //错误，函数必须声明的时候被实现
}
和Java一样，C#不允许有全局函数。所有的函数必须在类或结构内实现。函数是类或结构的成员，函数也被称为方法。
C#允许可以在类的声明中加入结尾分号，例如：
              sealed class Methods
              {
                            ...
              };//可以有结尾分号
但是，C#不允许在函数的声明中加入结尾分号，例如：
              sealed class Methods
              {
                            void NotAllowed() {...} ; //错误，函数不能有结尾分号
              }
2.声明函数
         函数参数列表
        各参数以逗号隔开
       参数必须命名
        没有参数时括号不能省略
sealed class Methods
{
void Error(float) //错误，参数没有命名
    { ...
    }
    void NoError(float delta)
    { ...
    }
 
 int Error(void) //错误，无参数时不允许使用void
    { ...
    }
    int NoError()
    { ...
}
}
3. 值型参数
                    一般的函数参数是实参的一个拷贝
        实参必须预先被赋值
       实参可以是常量类型
sealed class ParameterPassing
{
    static void Method(int parameter)
    {
        parameter = 42;  
    }
    static void Main()
    {
        int arg = 0;
        Console.Write(arg); //结果为0
        Method(arg);
        Console.Write(arg); //结果为0
    }
}
（注：为了叙述的方便，以后所出现的“参数”这个词均指函数参数，也就是所谓的形参）
没有被ref 或 out修饰的函数参数是一个值型参数。值型参数只有在该参数所属的函数被调用的时候才存在，并且用调用时所传递的实参的值来进行初始化。当函数调用结束时，值型参数不复存在。
只有被预先赋值的实参才能被传递给值型参数，例如：
              int arg;    // arg没有被赋初值
              Method(arg);//错误，实参必须预先赋初值
传递给函数的实参可以是纯粹的数而不是变量，例如：
              Method(42);
              Method(21 + 21);
4.c#教程引用型参数
                    引用型参数是实参的一个别名
       没有发生复制
       实参必须预先被赋值
       实参必须是一个变量类型
       实参和函数参数都要有ref
sealed class ParameterPassing
{
    static void Method(ref int parameter)
    {
        parameter = 42;
    }
    static void Main()
    {
        int arg = 0;
        Console.Write(arg); //结果为0
        Method(ref arg);
        Console.Write(arg); //结果为42
    }
}
函数参数有ref修饰符时，被称为引用型参数。引用型参数不产生新的存储区间。实际上，引用型参数是函数调用时所传递的实参所代表的变量的别名。结果是引用型参数只是实参所代表的变量的另一个名字。
ref修饰符必须同时出现在函数声明语句和函数调用语句中。
只有被预先赋值的实参才能被传递给引用型参数，例如：
              int arg;    // arg没有被赋初值
              Method(ref arg);//错误，实参必须预先赋初值
传递给引用型参数的实参必须是变量类型，而不能是纯粹的值或常量。
              Method(ref 42);  //错误，引用型参数的实参不能是纯粹的值
              const int arg = 42;
Method(ref arg); //错误，引用型参数的实参不能是常量
5.out型参数
                    out型参数是实参的一个别名
        没有发生复制
        实参不必预先赋值
        实参必须是变量类型
        函数参数必须被预先赋值才能使用
       实参和函数参数都要有out
sealed class ParameterPassing
{
    static void Method(out int parameter)
    {
        parameter = 42;
    }
    static void Main()
    {
        int arg;
        //Console.Write(arg);
        Method(out arg);
        Console.Write(arg); //结果为42
    }
}
函数参数有out修饰符时，被称为out型参数。out型参数不产生新的存储区间。实际上，out型参数是函数调用时所传递的实参所代表的变量的别名。结果是out型参数只是实参所代表的变量的另一个名字。
out修饰符必须同时出现在函数声明语句和函数调用语句中。
没有被预先赋值的实参能够被传递给引用型参数，例如：
              int arg;    // arg没有被赋初值
              Method(out arg);//正确，实参可以不赋初值
传递给out型参数的实参必须是变量类型，而不能是纯粹的值或常量。
              Method(out 42);  //错误，out型参数的实参不能是纯粹的值
              const int arg = 42;
Method(out arg); //错误，out型参数的实参不能是常量
6.in型参数?
                   readonly, const 和 in, 都是C# 关键字
       它们不能被用于函数参数
       ref/out 型参数总是被赋于写的权力
7.函数重载
                   一个类中的函数可以有同一个名字，称为重载
       函数名和参数称为标识
       标识必须唯一
       返回值类型不是标识
namespace System
{
    public sealed class Console
    {
        public static void WriteLine()
        { ... }
        public static void WriteLine(int value)
        { ... }
        public static void WriteLine(double value)
        { ... }
        ...
        public static void WriteLine(object value)
        { ... }
        ...
    }
}
和C++与Java一样，C#允许一个类声明两个以上的同名函数，只要参数的类型或个数不同。这就是重载。但是，一个类不能包含标识为相同的实例函数和静态函数，例如：
              sealed class Illegal
              {
                            void Overload() { ... }
                            static void Overload() { ... }//错误
              }
和C++与Java一样，返回值的类型不是标识的一部分，不能被用作重载的标准，例如：
              sealed class AlsoIllegal
              {
                            int Random() { ... }
                            double Random() { ... }//错误
              }
8.ref/out重载
                    ref / out 在大部分情况下是标识的一部分!
       你可以重载一个ref型参数和一个普通参数
       你可以重载一个out型参数和一个普通参数
       你不可以重载一个ref型参数和一个out型参数
sealed class Overloading
{
    void Allowed(    int parameter)
    { ... }
    void Allowed(ref int parameter)
    { ... }
   //正确，重载一个ref型参数和一个普通参数
 
    void AlsoAllowed(    int parameter)
    { ... }
    void AlsoAllowed(out int parameter)
{ ... }
//正确，重载一个out型参数和一个普通参数
 
    void NotAllowed(ref int parameter)
    { ... }
    void NotAllowed(out int parameter)
{ ... }
//错误，不能重载一个ref型参数和一个out型参数
}
ref和out修饰符可以是一个函数的标识。但是你不能同时重载ref和out型参数。ref和out修饰符在某种意义上是“安全的“，因为只有ref型实参才能传递给ref型函数参数，只有out型实参才能传递给out型函数参数。但是，当调用函数的时候，你会非常容易忘记ref和out修饰符，所以最好不要重载ref和out型参数。例如：
              sealed class Overloading
              {
                     public static void Example(int parameter)
                     { ... }
                     public static void Example(ref int parameter)
                     { ... }
                     static void Main()
                     {
                            int argument = 42;
                            Example(argument);//在这儿非常容易忘记ref修饰符
                     }
              }
9.访问规则
         c#教程函数参数或返回值不能比所属函数的访问级别低
sealed class T { ... } //类的默认访问级别是internal
public sealed class Bad
{
    public void Parameter(T t)  //错误，函数的访问级别（public）比参数高
    { ... }
    public T Return()             //错误，函数的访问级别（public）比返回值高
    { ... }
}
public sealed class Good
{
    private void Parameter(T t)  //正确，函数的访问级别（private）比参数低
    { ... }
    private T Return()            //正确，函数的访问级别（private）比返回值低
 
    { ... }
}
10.找错误
sealed class Buggy
{
    void Defaulted(double d = 0.0)             1
    { ...
    }
    void ReadOnly(const ref Wibble w)         2
    { ...
    }
    ref int ReturnType()                        3
    { ...
    }
    ref int fieldModifier;                     4
}
第1个函数的错误是：C#中函数不能拥有缺省参数。
第2个函数的错误是：ref型参数不能用const修饰，因为ref型参数是可能变化的。
第3,4个函数的错误是：ref和out型参数只能用于函数参数和实参。
C#中可以通过函数重载的办法实现缺省参数的功能，以下是实现的方法：
              sealed class Overload
              {
                            void DefaultArgument() { DefaultArgument(0.0); }
                            void DefaultArgument(double d) { ... }
              }