C#的方法的参数传递

一.按值传递

      按值传递是一种单向传递的方式。比如

• 实参：a,b【发送】
• 形参：x,y【接收】

当我们对形参做出调整的时候，实参是不会改变的；因为我们只是把实参的值传过去了，而不是地址。
举例：我们先建一个类Swaper,然后定义一个方法swap进行交换值的操作,其中的形参为a，b：

class Swaper{
	public int swap(int a,int b){
		int temp;
		temp=a;
		a=b;
		b=temp;
	}
}

然后我们再我们的控件按钮方法里准备调用这个方法，调用之前的思路就是，先定义本类的一个对象s：

private void btnOk_Click(object sender, EventArgs e)
{
	Swaper s=new Swaper();
	int x=Convert.ToInt32(txtOp1.Text);
	int y=Convert.ToInt32(txtOp2.Text);
	
	//交换前的实参
	 lblShow.Text = String.Format("主调方法：交换前：a={0},b={1}", a, b);
     lblShow.Text += s.Swap(a, b);//调用并传递参数[实参]

    //交换后的实参
    lblShow.Text += string.Format("\n\n主调方法：调用之后：a={0},b={1}", a, b);
    txtOp1.Text = a.ToString();
    txtOp2.Text = b.ToString();

}

注意：

String.Format("{0},{1}",a,b)

等价于

printf（"%d%d",a,b）

我们在swap方法里也打印一下我们的交换后的值看看：

   class Swaper//定义一个swaper类
    {
        public string Swap(int x,int y)//【形参】
        {
            //其实String.Format方法类似于printf方法，输出多个变量
            //方法执行前实参数值
            string str = string.Format("\n\n调用方法：交换前：x={0},y={1}", x, y);
            int temp;
            temp = x;
            x = y;
            y = temp;

            //方法执行后实参数值
            str += string.Format("\n\n被调方法：交换之后：x={0},y={1}", x, y);
            return str;
        }
    }

二.源代码：

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

namespace 实例4_3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnOk_Click(object sender, EventArgs e)
        {
            Swaper s = new Swaper();
            int a = Convert.ToInt32(txtOp1.Text);
            int b = Convert.ToInt32(txtOp2.Text);
            lblShow.Text = String.Format("主调方法：交换前：a={0},b={1}", a, b);
            lblShow.Text += s.Swap(a, b);//调用并传递参数[实参]
            //显示调用后的实参值
            lblShow.Text += string.Format("\n\n主调方法：调用之后：a={0},b={1}", a, b);
            txtOp1.Text = a.ToString();
            txtOp2.Text = b.ToString();
        }
    }

    class Swaper//定义一个swaper类
    {
        public string Swap(int x,int y)//【形参】
        {
            //其实String.Format方法类似于printf方法，输出多个变量
            //方法执行前实参数值
            string str = string.Format("\n\n调用方法：交换前：x={0},y={1}", x, y);
            int temp;
            temp = x;
            x = y;
            y = temp;

            //方法执行后实参数值
            str += string.Format("\n\n被调方法：交换之后：x={0},y={1}", x, y);
            return str;
        }
    }
}

三.按引用传参

      按引用传值是将实参地址传给形参地址的意思；这样在形参做出任何改变的时候，实参也会发生改变！也就是说实参a，b和x，y的内存单元是一样的！

首先引用参数的关键字是：ref

扫描二维码关注公众号，回复： 11343369 查看本文章

只需要在实参和形参的前面加上关键字即可；所以我们依然用上面的例子来作比喻，在a，b和x，y前面加上ref

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

namespace 实例4_3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnOk_Click(object sender, EventArgs e)
        {
            Swaper s = new Swaper();
            int a = Convert.ToInt32(txtOp1.Text);
            int b = Convert.ToInt32(txtOp2.Text);
            lblShow.Text = String.Format("主调方法：交换前：a={0},b={1}", a, b);
            lblShow.Text += s.Swap(ref a,ref b);//调用并传递参数[实参]
            //显示调用后的实参值
            lblShow.Text += string.Format("\n\n主调方法：调用之后：a={0},b={1}", a, b);
            txtOp1.Text = a.ToString();
            txtOp2.Text = b.ToString();
        }
    }

    class Swaper//定义一个swaper类
    {
        public string Swap(ref int x,ref int y)//【形参】
        {
            //其实String.Format方法类似于printf方法，输出多个变量
            //方法执行前实参数值
            string str = string.Format("\n\n调用方法：交换前：x={0},y={1}", x, y);
            int temp;
            temp = x;
            x = y;
            y = temp;

            //方法执行后实参数值
            str += string.Format("\n\n被调方法：交换之后：x={0},y={1}", x, y);
            return str;
        }
    }
}

四.输出参数

      输出参数就是把方法里的形参回传给我们的主调里的实参去，也算一种单向传递；只不过和第一种值传递逆过来了！
关键字是：out
为什么引入它？因为平时在涉及到参数传递的时候，都是实参传给形参，现在可以反过来了，把我们的形参传给实参；这样做的好处有：

1. 不需要return了；
2. 不需要对实参初始化；

我们建一个类Analyser，写一个方法SplitPath和3个参数，我们在方法里分别获取3个参数值：

   class Analyzer
    {
        public void SplitPath(string path,out string dir,out string filename)
        {
            int i;
            i = path.LastIndexOf("\\");//获取最后一个反斜杠的位置
            dir = path.Substring(0, i);//获取最后一个反斜杠之前的字符串时文件目录
            filename = path.Substring(i + 1);//最后一个反斜杠的字符串时文件名
        }
    }

我们发现我们的方法里没有return了，但是我们获取到的数据回传过去了，这就是输出参数的功劳！

准备调用它：

  private void btnOK_Click(object sender, EventArgs e)
        {
            Analyzer a = new Analyzer();
            string path = txtPath.Text;
            string dir, file;
            a.SplitPath(path, out dir, out file);
            txtDir.Text = dir;
            txtFilename.Text = file;
        }

源代码：

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

namespace 实例4_4
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnOK_Click(object sender, EventArgs e)
        {
            Analyzer a = new Analyzer();
            string path = txtPath.Text;
            string dir, file;
            a.SplitPath(path, out dir, out file);
            txtDir.Text = dir;
            txtFilename.Text = file;
        }
    }

    class Analyzer
    {
        public void SplitPath(string path,out string dir,out string filename)
        {
            int i;
            i = path.LastIndexOf("\\");//获取最后一个反斜杠的位置
            dir = path.Substring(0, i);//获取最后一个反斜杠之前的字符串时文件目录
            filename = path.Substring(i + 1);//最后一个反斜杠的字符串时文件名
        }
    }
}