函数I

1. 采用参数形式为函数提供信息，以返回值的形式得到函数的结果。

函数的名称和参数(不是返回类型)共同定义了函数的签名。

一般采用PascalCase形式编写函数名，即首字母大写。（CamelCase是首字母小写的意思）

2. 定义函数，调用函数

1）两个关键字：static和void 
2）函数名后跟圆括号，如Write() 
3）一个要执行的代码块，放在花括号中

例如

static void Write()   //static与面向对象的概念有关，void是说函数没有返回值
{ 
Console.WriteLine("Text output from function."); 
}

static void Main(string[] args)   //Main函数是控制台应用程序的入口点函数
{ 
Write();   //调用函数
Console.ReadKey(); 
}

3. 有返回值的函数，可以这样调用（在返回值数据类型不需要改变的情况下）

string myString; 
myString = GetString(); 

或

double myVal; 
double multiplier = 5.3; 
myVal = GetVal() * multiplier; 

4. 有返回值的函数

1）在函数声明中指定返回值的类型，但不使用关键字void。

static double GetVal() 
{ 
return 3.2; 
} 

2）使用return关键字结束函数的执行，把返回值传递给调用代码。

static double GetVal() 
{ 
double checkVal; 
// CheckVal assigned a value through some logic (not shown here). 
if (checkVal < 5) 
return 4.7; 
return 3.2; 
} 

5. 有参数的函数

函数在其定义中指定要接受的参数列表，以及这些参数的类型。

在每个函数调用中匹配的参数列表。

例如

static double Product(double param1, double param2) 
{ 
return param1 * param2; 
}

例如

     static int MaxValue(int[] intArray)  //该函数的参数是一个整数数组intArray
        {
            int maxVal = intArray[0];
            for (int i = 1; i < intArray.Length; i++)  //此例中，intAeey.Length就是9，就是数组一共有几个数
            {
                if (intArray[i] > maxVal)
                    maxVal = intArray[i];
            }
            return maxVal;
        }
        static void Main(string[] args)
        {
            int[] myArray = { 1, 8, 3, 6, 2, 5, 9, 3, 0, 2 };
            int maxVal = MaxValue(myArray);
            Console.WriteLine("The maximum value in myArray is {0}", maxVal);
            Console.ReadKey();
        }

6. 参数要匹配

在调用函数时，必须使参数与函数定义中指定的参数完全匹配，

这意味着要匹配参数的类型、个数和顺序。

7. 使用参数数组的函数，params 关键字

C#允许为函数指定一个(只能指定一个)特定的参数，这个参数必须是函数定义中的最后一个参数，

称为参数数组。

参数数组可以使用个数不定的参数调用函数，可以使用params关键字定义它们。

可以指定的参数个数几乎不受限制。

唯一的限制是它们都必须是<type>类型。甚至可以根本不指定参数。

例如

定义参数数组函数

static <returnType> <FunctionName>(<p1Type> <p1Name>, ...,

params <type>[ ] <name>) 
{ 
... 
return <returnValue>; 
} 

调用该函数

<FunctionName>(<p1>, ..., <val1>, <val2>, ...) 

例子

static int SumVals(params int[] vals)  //该函数可以接受任意个int 参数(但不接受其他类型的参数)
        {
            int sum = 0;
            foreach (int val in vals)
            {
                sum += val;
            }
            return sum;
        }
        static void Main(string[] args)
        {
            int sum = SumVals(1, 5, 2, 9, 8);
            Console.WriteLine("Summed Values = {0}", sum);
            Console.ReadKey();
        }

8. 引用参数和值参数，ref 关键字

例子1

static void ShowDouble(int val) 
{ 
val *= 2; 
Console.WriteLine("val doubled = {0}", val); 
} 

调用

int myNumber = 5; 
Console.WriteLine("myNumber = {0}", myNumber); 
ShowDouble(myNumber); 
Console.WriteLine("myNumber = {0}", myNumber); 

结果是

myNumber = 5 

val doubled = 10 

myNumber = 5 

例子2

static int DoubleNum(int val) 
{ 
val *= 2; 
return val; 
}

调用

int myNumber = 5; 
Console.WriteLine("myNumber = {0}", myNumber); 
myNumber = DoubleNum(myNumber); 
Console.WriteLine("myNumber = {0}", myNumber); 

结果是

myNumber = 5 

myNumber = 10

例子3

static void ShowDouble(ref int val) 
{ 
val *= 2; 
Console.WriteLine("val doubled = {0}", val); 
}

调用

int myNumber = 5; 
Console.WriteLine("myNumber = {0}", myNumber); 
ShowDouble(ref myNumber); 
Console.WriteLine("myNumber = {0}", myNumber); 

结果是

myNumber = 5 
val doubled = 10 
myNumber = 10 

9. 输出参数，out 关键字

把未赋值的变量用作 ref 参数是非法的，但可以把未赋值的变量用作 out 参数。

在函数使用out参数时，out参数必须看作是还未赋值。

即调用代码可以把已赋值的变量用作out参数，存储在该变量中的值会在函数执行时丢失。

意思就是：使用out 时，提前赋不赋值都无所谓，因为它是要去函数里拿值。

但是使用ref 时，必须要提前赋值，不然会出现错误提示。

例如

static int MaxValue(int[] intArray, out int maxIndex)   //注意out以及后面的部分，之前的例子里没有
{ 
int maxVal = intArray[0]; 
maxIndex = 0; 
for (int i = 1; i < intArray.Length; i++) 
{ 
if (intArray[i] > maxVal) 
{ 
maxVal = intArray[i]; 
maxIndex = i; 
} 
} 
return maxVal; 
} 

调用

int[] myArray = { 1, 8, 3, 6, 2, 5, 9, 3, 0, 2 }; 
int maxIndex; 
Console.WriteLine("The maximum value in myArray is {0}", 
MaxValue(myArray, out maxIndex)); 
Console.WriteLine("The first occurrence of this value is at element {0}", 
maxIndex + 1);   //在屏幕上显示结果时，给返回的maxIndex的值加上1。这样可以使索引更容易读懂，因此数组的第一个元素称为元素1，而不是元素0。

结果是

The maximum value in myArray is 9 
The first occurrence of this value is at element 7 

10. 变量的作用域

class Program 
{ 
static void Write() 
{ 

string myString = "String defined in Write()";   // 2，Write中定义和初始化字符串变量String，与Main中的myString完全不一样
Console.WriteLine("Now in Write()");   // 3，输出
Console.WriteLine("myString = {0}", myString);   // 4，输出
} 
static void Main(string[] args) 
{ 
string myString = "String defined in Main()";   // 1，Main中定义和初始化字符串变量String
Write(); 

Console.WriteLine("\nNow in Main()");   // 5，输出
Console.WriteLine("myString = {0}", myString);  // 6，输出
Console.ReadKey(); 
} 
} 

变量是有作用域的，在这个作用域中，变量才是有效的。

这个作用域包括定义变量的代码块和直接嵌套在其中的代码块。

函数中的代码块与调用它们的代码块是不同的。

在Write()中，没有定义myString，在Main()中定义的myString则超出了作用域——它只能在Main()中使用。

其作用域以这种方式覆盖一个函数的变量称为局部变量。

11. 全局变量，通常不使用

其作用域可覆盖多个函数

例如

class Program 
{ 
static string myString;   //定义全局变量，使用关键字static或const
static void Write() 
{ 
string myString = "String defined in Write()"; 
Console.WriteLine("Now in Write()"); 
Console.WriteLine("Local myString = {0}", myString); 
Console.WriteLine("Global myString = {0}", Program.myString); 
} 
static void Main(string[] args) 
{ 
string myString = "String defined in Main()"; 

Program.myString = "Global string";   //全局变量和局部变量同名时，需要这种方式
Write(); 
Console.WriteLine("\nNow in Main()"); 
Console.WriteLine("Local myString = {0}", myString); 
Console.WriteLine("Global myString = {0}", Program.myString);   //访问全局变量
Console.ReadKey(); 
} 
} 

这里把全局变量称为Program.myString。

注意，在全局变量和局部变量同名时，这是必需的。

如果没有局部myString变量，就可以使用myString表示全局变量，而不需要使用Program.myString。

如果局部变量和全局变量同名，全局变量就会被屏蔽。

12. 变量的作用域包含定义它们的代码块和直接嵌套在其中的代码块。

这也可以应用到其他代码块上，例如分支和循环结构的代码块。

13. 一个变量，要在循坏外和内都要声明和初始化，这样，

当退出循环时，调用这个变量，它的值就是退出循环时的值。

否则，就不是这个结果。例如

int i; 
string text = ""; 
for (i = 0; i < 10; i++) 
{ 
text = "Line " + Convert.ToString(i); 
Console.WriteLine("{0}", text); 
} 
Console.WriteLine("Last text output in loop: {0}", text); 

14. 一般情况下，最好在声明和初始化所有变量后，再在代码块中使用它们。

一个例外是把循环变量声明为循环块的一部分，例如

for (int i = 0; i < 10; i++) 
{ 
... 
} 

其中i局部化于循环代码块中，但这是可以的，因为很少需要在外部代码中访问这个计数器。

15. 

16. Main()函数

Main()是C#应用程序的入口点，执行这个函数就是执行应用程序。

也就是说，在执行过程开始时，会执行Main()函数，在Main()函数执行完毕时，执行过程就结束了。

17. Main()函数可以使用如下4种版本：

static void Main() 
static void Main(string[] args) 
static int Main() 
static int Main(string[] args) 

上面的第二、四个版本返回一个int 值，它们可以用于表示应用程序如何终止，

通常用作一种错误提示(但这不是强制的)，

一般情况下，返回0反映了“正常”的终止(即应用程序执行完毕，并安全地终止)。

Main()的可选参数args是从应用程序的外部接受信息的方法，

这些信息在运行期间指定，其形式是命令行参数。