out关键字和ref关键字的区别

我们只需要知道一点，out经常用在多个参数的输出
ref用在数据的双向传递就好了

public string GetString()
{
   return "Hello,World!";
}
var s=GetString();

这是一个简单输出string的方法，但是只输出了一个参数
我们输出两个参数或者多个参数也会用到枚举，元组，列表，数组
虽然枚举，元组，列表，数组能输出多个参数，但是它们要进行相应的转化和赋值
使用out就比较简单了

public void GetString(out int a,out int b)
{
   a=1,b10;
}
int a,b;
GetString(out a,out b);
Console.WriteLine(a);
Console.WriteLine(b);

我们现在尝试同时使用ref和out写一个demo

public class RefDemo
{
    public void UsageInt(ref int a, ref int b)
    {
        a = 1; b = 999;
    }

    public void UsageString(ref string a, ref string b)
    {
        a = "123";
        b = "321";
    }
}

 public class OutDemo
 {
     public void UsageInt(out int a,out int b)
     {
         a = 1;b = 999;
     }

     public void UsageString(out string a,out string b)
     {
         a = "123";
         b = "321";
     }
 }
public static void UsageOut()
{
    OutDemo outDemo = new OutDemo();
    int a, b;
    outDemo.UsageInt(out a, out b);
    Console.WriteLine(a);
    Console.WriteLine(b);

    Console.WriteLine("======================");
    string a2, b2;
    outDemo.UsageString(out a2, out b2);
    Console.WriteLine(a2);
    Console.WriteLine(b2);
}

public static void UsageRef()
{
    RefDemo refDemo = new RefDemo();
    int a=0, b=0;
    refDemo.UsageInt(ref a, ref b);
    Console.WriteLine(a);
    Console.WriteLine(b);

    Console.WriteLine("======================");
    string a2="", b2="";
    refDemo.UsageString(ref a2, ref b2);
    Console.WriteLine(a2);
    Console.WriteLine(b2);
}

输出结果

1
999
======================
123
321

从上面的demo可以看出，我们使用两个关键字除了最开始初始化不同，其他的结果都一样
其中out关键字可以看作ref的子集，out比ref关键字强大，因为它不需要初始化，
但是这是假相，没有很好的体现出ref的作用，我这里写这两个demo，是先让你们熟悉这两个关键字的用法
接下来我们看看两个关键字的区别

 public static void Ref()
 {
     int number = 10;
     Console.WriteLine("原始值: " + number);

     ModifyNumberFromRef(ref number);
     Console.WriteLine("修改后的值: " + number);

     number = 100;
     Console.WriteLine("再次修改原始值: " + number);

     ModifyNumberFromRef(ref number);
     Console.WriteLine("再次修改后的值: " + number);
 }

 static void ModifyNumberFromRef(ref int num)
 {
     num *= 2;
     Console.WriteLine("在方法内部修改后的值: " + num);
 }

 public static void Out()
 {
     int number = 10;
     Console.WriteLine("原始值: " + number);

     ModifyNumberFromOut(out number);
     Console.WriteLine("修改后的值: " + number);

     number = 100;
     Console.WriteLine("再次修改原始值: " + number);

     ModifyNumberFromOut(out number);
     Console.WriteLine("再次修改后的值: " + number);
 }

 static void ModifyNumberFromOut(out int num)
 {
     num= 100;
     num *= 2;
     Console.WriteLine("在方法内部修改后的值: " + num);
 }

输出结果

原始值: 10
在方法内部修改后的值: 20
修改后的值: 20
再次修改原始值: 100
在方法内部修改后的值: 200
再次修改后的值: 200
-------------------------
原始值: 10
在方法内部修改后的值: 200
修改后的值: 200
再次修改原始值: 100
在方法内部修改后的值: 200
再次修改后的值: 200

通过输出我们可以很明显看出两个关键字的区别