C#的方法参数的无修饰符以及 in、out、ref(in/out) 修饰符的区别

无修饰符

无修饰符的参数有如下特点：

• 传入的参数可以重新赋值
• 不影响传入参数的原始值

IN 修饰符

IN 修饰符的参数有如下特点：

• 传入的参数不可以重新赋值
• 不影响传入参数的原始值

OUT 修饰符

OUT 修饰符的参数有如下特点：

• 传入的参数不需要赋值
• 影响传入参数的原始值
• 在函数返回值之前需要对 out 修饰的参数赋值

REF(IN/OUT) 修饰符

OUT 修饰符的参数有如下特点：

• 传入的参数可以重新赋值
• 影响传入参数的原始值

示例代码

using System;

namespace Demo
{
    public class HelloWorld
    {
        public string Hello { get; set; } = "Hello";

        public string World { get; set; } = "World";

        public string Space { get; set; } = " ";

        public override string ToString()
        {
            return Hello + Space + World;
        }
    }
    public class Program
    {
        static void Main(string[] args)
        {
            var hello = "Hello";
            var space = " ";
            var world = "World";
            Console.WriteLine("原始值：");
            Console.WriteLine(hello + space + world);
            Console.WriteLine("---------------------");
            Console.WriteLine("JoinText（无修饰符）：");
            var value1 = JoinText(hello, space, world);
            Console.WriteLine("调用函数后的原始值:" + hello + space + world);
            Console.WriteLine("调用函数后的结果值:" + value1);
            Console.WriteLine("---------------------");
            Console.WriteLine("JoinText（in 修饰符）：");
            var value2 = JoinTextIn(in hello, in space, in world);
            Console.WriteLine("调用函数后的原始值:" + hello + space + world);
            Console.WriteLine("调用函数后的结果值:" + value2);
            Console.WriteLine("---------------------");
            Console.WriteLine("JoinText（out 修饰符）：");
            string value3 = "你好";//没有必要赋值
            JoinTextOut(hello, space, world, out value3);
            Console.WriteLine("调用函数后的原始值:" + hello + space + world);
            Console.WriteLine("调用函数后的结果值:" + value3);
            Console.WriteLine("---------------------");
            Console.WriteLine("JoinText（ref[in/out] 修饰符）：");
            var value4 = JoinTextRef(ref hello, ref space, ref world);
            Console.WriteLine("调用函数后的原始值:" + hello + space + world);
            Console.WriteLine("调用函数后的结果值:" + value4);

            Console.WriteLine("---------------------");
            Console.WriteLine("hello world 原始对象：");
            var hw = new HelloWorld();
            Console.WriteLine(hw.ToString());
            Console.WriteLine("---------------------");
            Console.WriteLine("HelloWorldChinese(无修饰符)：");
            var hw1 = new HelloWorld();
            var hw1Cn = HelloWorldChinese(hw1);
            Console.WriteLine("调用函数后的原始值:" + hw1.ToString());
            Console.WriteLine("调用函数后的结果值:" + hw1Cn.ToString());
            Console.WriteLine("---------------------");
            Console.WriteLine("HelloWorldChinese( in 修饰符)：");
            var hw2 = new HelloWorld();
            var hw2Cn = HelloWorldChineseIn(hw2);
            Console.WriteLine("调用函数后的原始值:" + hw2.ToString());
            Console.WriteLine("调用函数后的结果值:" + hw2Cn.ToString());
            Console.WriteLine("---------------------");
            Console.WriteLine("HelloWorldChinese( out 修饰符)：");
            var hw3 = new HelloWorld();
            HelloWorldChineseOut(hw3, out HelloWorld hw3Cn);
            Console.WriteLine("调用函数后的原始值:" + hw3.ToString());
            Console.WriteLine("调用函数后的结果值:" + hw3Cn.ToString());
            Console.WriteLine("---------------------");
            Console.WriteLine("HelloWorldChinese( ref 修饰符)：");
            var hw4 = new HelloWorld();
            var hw4Cn = HelloWorldChineseRef(ref hw4);
            Console.WriteLine("调用函数后的原始值:" + hw4.ToString());
            Console.WriteLine("调用函数后的结果值:" + hw4Cn.ToString());
        }

        /// <summary>
        /// 拼接文本
        /// </summary>
        /// <param name="hello"></param>
        /// <param name="space"></param>
        /// <param name="world"></param>
        /// <returns></returns>
        public static string JoinText(string hello, string space, string world)
        {
            hello = "你好";
            world = "世界";
            return hello + space + world;
        }

        /// <summary>
        /// 拼接文本，使用 in 修饰符的参数无法重新赋值，如 hello="你好;只能定义新的变量赋值
        /// </summary>
        /// <param name="hello"></param>
        /// <param name="space"></param>
        /// <param name="world"></param>
        /// <returns></returns>
        public static string JoinTextIn(in string hello, in string space, in string world)
        {
            //无法分配到 变量 'in string' ，因为它是只读变量
            //无法分配到 变量 'in string' ，因为它是只读变量
            //hello = "你好";//只读变量，不能重新赋值,只能读取
            //world = "世界";//只读变量，不能重新赋值,只能读取
            //return hello + space + world;

            var hello2 = "你好";
            var world2 = "世界";
            return hello2 + space + world2;
        }

        /// <summary>
        /// 拼接文本，使用 out 修饰符的参数不需要进行赋值（此行为无意义），因为是用于接收返回值用的，
        /// 同样，在函数结束前（如提前 return），函数内需要对 out 的参数赋值
        /// </summary>
        /// <param name="hello"></param>
        /// <param name="space"></param>
        /// <param name="world"></param>
        /// <returns></returns>
        public static void JoinTextOut(string hello, string space, string world, out string result)
        {
            hello = "你好";
            world = "世界";
            result = hello + space + world;
        }

        /// <summary>
        /// 拼接文本，使用 ref 修饰符的参数修改了值，对调用函数传的原始参数的值也会修改
        /// </summary>
        /// <param name="hello"></param>
        /// <param name="space"></param>
        /// <param name="world"></param>
        /// <returns></returns>
        public static string JoinTextRef(ref string hello, ref string space, ref string world)
        {
            hello = "你好";
            world = "世界";
            return hello + space + world;
        }

        /// <summary>
        /// hello world 汉化
        /// </summary>
        /// <param name="helloWorld"></param>
        /// <returns></returns>
        public static HelloWorld HelloWorldChinese(HelloWorld helloWorld)
        {
            var helloWorld2 = new HelloWorld()
            {
                Hello = "你好",
                World = "世界"
            };
            helloWorld = helloWorld2;
            return helloWorld;
        }

        /// <summary>
        /// hello world 汉化
        /// </summary>
        /// <param name="helloWorld"></param>
        /// <returns></returns>
        public static HelloWorld HelloWorldChineseIn(in HelloWorld helloWorld)
        {
            var helloWorld2 = new HelloWorld()
            {
                Hello = "你好",
                World = "世界"
            };
            //helloWorld = helloWorld2;//只读变量，不能重新赋值,只能读取
            return helloWorld2;
        }

        /// <summary>
        /// hello world 汉化
        /// </summary>
        /// <param name="helloWorld"></param>
        /// <returns></returns>
        public static void HelloWorldChineseOut(HelloWorld helloWorld, out HelloWorld result)
        {
            var helloWorld2 = new HelloWorld()
            {
                Hello = "你好",
                World = "世界"
            };
            helloWorld = helloWorld2;
            result = helloWorld;
        }

        /// <summary>
        /// hello world 汉化
        /// </summary>
        /// <param name="helloWorld"></param>
        /// <returns></returns>
        public static HelloWorld HelloWorldChineseRef(ref HelloWorld helloWorld)
        {
            var helloWorld2 = new HelloWorld()
            {
                Hello = "你好",
                World = "世界"
            };
            helloWorld = helloWorld2;
            return helloWorld;
        }
    }
}

示例代码结果

原始值：
Hello World
---------------------
JoinText（无修饰符）：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
JoinText（in 修饰符）：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
JoinText（out 修饰符）：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
JoinText（ref[in/out] 修饰符）：
调用函数后的原始值:你好 世界
调用函数后的结果值:你好 世界
---------------------
hello world 原始对象：
Hello World
---------------------
HelloWorldChinese(无修饰符)：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
HelloWorldChinese( in 修饰符)：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
HelloWorldChinese( out 修饰符)：
调用函数后的原始值:Hello World
调用函数后的结果值:你好 世界
---------------------
HelloWorldChinese( ref 修饰符)：
调用函数后的原始值:你好 世界
调用函数后的结果值:你好 世界