C#中三个关键字-ref,out ,params

来源：互联网发布：不要网络的单机麻将编辑：程序博客网时间：2024/05/21 10:03

C#中有三个关键字-ref,out ,params，我们来认识一下参数修饰符ref,out ,params吧，还有它们的区别。

NO.1 params　一个可以让方法（函数）拥有可变参数的关键字。
原则：在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字。
示例（拷贝到vs2005中即可用）

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace parameteroutref
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 可变参数个数
        /// </summary>
        /// <param name="list"></param>
        public static void UseParams(params int[] list)
        {
            string temp = "";
            for (int i = 0; i < list.Length; i++)
                temp = temp +" " +list[i].ToString();
            MessageBox.Show(temp);
        }
        /// <summary>
        /// 可变参数类型和个数
        /// </summary>
        /// <param name="list"></param>
        public static void UseParams2(params object[] list)
        {
            string temp = "";
            for (int i = 0; i < list.Length; i++)
                temp = temp + " " + list[i].ToString();
            MessageBox.Show(temp);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            UseParams(1, 2, 3);//看参数是3个
            UseParams(1, 2);   //看参数是2个，可变吧

            UseParams2(1, 'a', "test");//一个整型，两个字符串，类型可变

            int[] myarray = new int[3]{ 10, 11, 12 };
            UseParams(myarray); //看也可以是容器类，可变吧：）

}
}
}

NO.2 out　这是一个引用传递L。
原则一：当一个方法（函数）在使用out作为参数时，在方法（函数）中对out参数所做的任何更改都将反映在该变量中。
原则二：当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法可以返回一个或一个以上的 out 参数。
原则三：若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
原则四：不必初始化作为 out 参数传递的变量，因为out 参数在进入方法（函数）时后清空自己，使自己变成一个干净的参数，也因为这个原因必须在方法返回之前为 out 参数赋值（只有地址没有值的参数是不能被.net接受的）。
原则五：属性不是变量，不能作为 out 参数传递。
原则六：如果两个方法的声明仅在 out 的使用方面不同，则会发生重载。不过，无法定义仅在 ref 和 out 方面不同的重载。例如，以下重载声明是有效的：
class MyClass
{
public void MyMethod(int i) {i = 10;}
public void MyMethod(out int i) {i = 10;}
}
而以下重载声明是无效的：
class MyClass
{
public void MyMethod(out int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}
}
NO.3 ref　ref仅仅是一个地址！！！
原则一：当一个方法（函数）在使用ref作为参数时，在方法中（函数）对ref参数所做的任何更改都将反映在该变量中。
原则二：调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
原则三：若要使用 ref 参数，必须将参数作为 ref 参数显式传递到方法。ref 参数的值可以被传递到 ref 参数。
原则四：ref参数传递的变量必须初始化，因为ref参数在进入方法（函数）时后还是它自己，它这个地址指向的还是原来的值，也因为这个原因ref参数也可以在使用它的方法内部不操作。
原则六：如果两种方法的声明仅在它们对 ref 的使用方面不同，则将出现重载。但是，无法定义仅在 ref 和 out 方面不同的重载。例如，以下重载声明是有效的：
class MyClass
{
public void MyMethod(int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}
}
但以下重载声明是无效的：
class MyClass
{
public void MyMethod(out int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}
}

out 与ref 比较示例代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace parameteroutref
{
    public partial class outref : Form
    {
        public outref()
        {
            InitializeComponent();
        }
        private void outref_Load(object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 使用 out 参数的方法可以返回一个 out 参数。
        /// </summary>
        /// <param name="s"></param>
        private void outTestSingle(out string s)
        {
            s = "My Value has Changed!"; //必须要对s赋值,否则错误 1控制离开当前方法之前必须对 out 参数“s”赋值
        }

        /// <summary>
        /// 两个方法的声明仅在 out 的使用方面不同，则发生重载
        /// </summary>
        /// <param name="s"></param>
        private void outTestSingle(string s)
        {
            s = "My Value has Changed!";
        }

        //private void outTestSingle(ref string s)//错误 1 “outTestSingle”不能定义仅在 ref 和 out 上有差别的重载方法
        //{
        //    s = "My Value has Changed!";
        //}

        /// <summary>
        /// 用 out 参数的方法可以返回一个以上的 out 参数。
        /// </summary>
        /// <param name="n1"></param>
        /// <param name="s1"></param>
        private void outTestMutiple(out int n1,out string s1)
        {
            n1 = 100;
            s1 = "outtest";
        }
        /// <summary>
        /// 测试out
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            string s="My old value!";
            outTestSingle(s);//普通函数值并未发生改变
            MessageBox.Show(s);

outTestSingle(out s);
MessageBox.Show(s);//值已在被调函数中发生了改变

            int i;
            string s2;//在传之前可以不进行初始化
            outTestMutiple(out i, out s2);
            MessageBox.Show(i.ToString() + " " + s2);
        }

        private void refTest(ref string s)
        {
            //可以不对s赋值，因为ref 传参时是带值的
        }
        private void refTest1(ref string s)
        {
            s = "refstring changed";//也可以赋值
        }

        private void button2_Click(object sender, EventArgs e)
        {
            string s = "refstring";
            refTest(ref s);
            MessageBox.Show(s);

string s1;
refTest(ref s1);//出错s1必须初始化

            refTest1(ref s);
            MessageBox.Show(s);//值改变了
        }

}
}

综上，其实out与ref 的主要区别我已用红色字体标注：

１、out传参时只传地址，并不传值，所以在调用时参数可以不初始化，但在被调函数中

必须进行赋值；

２、ref传参时既传地址又传值，所以在调用时参数必须初始化，但在被调函数中可以不进行赋值。

３、其实这两条是有原因的，正如本文所讲“只有地址没有值的参数是不能被.net接受的”。