扩展狗和猫的例子。带有ref的第二个方法更改调用者引用的对象。所以叫“猫”!!

    public static void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog". 
        Bar(ref myObject);
        Console.WriteLine(myObject.Name); // Writes "Cat". 
    }

    public static void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

    public static void Bar(ref MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

扩展狗和猫的例子。带有ref的第二个方法更改调用者引用的对象。所以叫“猫”!!

    public static void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog". 
        Bar(ref myObject);
        Console.WriteLine(myObject.Name); // Writes "Cat". 
    }

    public static void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

    public static void Bar(ref MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

注意，在函数内部传递的引用参数是直接处理的。

例如,

    public class MyClass
    {
        public string Name { get; set; }
    }

    public void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog".
    }

    public void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

这会写狗，而不是猫。因此，您应该直接在someObject上工作。

out:

在c#中，一个方法只能返回一个值。如果希望返回多个值，可以使用out关键字。out修饰符返回为return-by-reference。最简单的答案是使用关键字“out”从方法中获取值。

您不需要在调用函数中初始化该值。 必须在被调用的函数中赋值，否则编译器将报错。

ref:

在c#中，当你将一个值类型，如int, float, double等作为参数传递给方法参数时，它是按值传递的。因此，如果修改形参值，它不会影响方法调用中的实参。但是，如果您用“ref”关键字标记参数，它将反映在实际的变量中。

在调用函数之前，需要初始化变量。 为方法中的ref参数赋值不是强制的。如果不更改值，为什么需要将其标记为“ref”?

除了允许你将别人的变量重新分配给类的不同实例，返回多个值等，使用ref或out可以让别人知道你需要从他们那里得到什么，以及你打算用他们提供的变量做什么

You don't need ref or out if all you're going to do is modify things inside the MyClass instance that is passed in the argument someClass. The calling method will see changes like someClass.Message = "Hello World" whether you use ref, out or nothing Writing someClass = new MyClass() inside myFunction(someClass) swaps out the object seen by the someClass in the scope of the myFunction method only. The calling method still knows about the original MyClass instance it created and passed to your method You need ref or out if you plan on swapping the someClass out for a whole new object and want the calling method to see your change Writing someClass = new MyClass() inside myFunction(out someClass) changes the object seen by the method that called myFunction

还有其他程序员

他们想知道你将如何处理他们的数据。假设您正在编写一个将被数百万开发人员使用的库。你想让他们知道当他们调用你的方法时你要对他们的变量做什么

Using ref makes a statement of "Pass a variable assigned to some value when you call my method. Be aware that I might change it out for something else entirely during the course of my method. Do not expect your variable to be pointing to the old object when I'm done" Using out makes a statement of "Pass a placeholder variable to my method. It doesn't matter whether it has a value or not; the compiler will force me to assign it to a new value. I absolutely guarantee that the object pointed to by your variable before you called my method, will be different by the time I'm done

顺便说一下，在c# 7.2中也有一个in修饰符

And that prevents the method from swapping out the passed in instance for a different instance. Think of it like saying to those millions of developers "pass me your original variable reference, and I promise not to swap your carefully crafted data out for something else". in has some peculiarities, and in some cases such as where an implicit conversion might be required to make your short compatible with an in int the compiler will temporarily make an int, widen your short to it, pass it by reference and finish up. It can do this because you've declared you're not going to mess with it.

微软对数值类型的.TryParse方法做到了这一点:

int i = 98234957;
bool success = int.TryParse("123", out i);

通过将参数标记为out他们在这里积极地声明"我们肯定会将你苦心制作的98234957值更改为其他值"

当然，对于像解析值类型这样的事情，它们有点不得不这样做，因为如果parse方法不允许将值类型替换为其他类型，那么它就不能很好地工作。但是想象一下在你创建的库中有一些虚构的方法:

public void PoorlyNamedMethod(out SomeClass x)

你可以看到它是一个out，因此你可以知道，如果你花了几个小时处理数字，创建一个完美的SomeClass:

SomeClass x = SpendHoursMakingMeAPerfectSomeClass();
//now give it to the library
PoorlyNamedMethod(out x);

那真是浪费时间，花那么多时间来做一节完美的课。它肯定会被丢弃，并被PoorlyNamedMethod取代

“贝克”

这是因为第一个将字符串引用更改为指向“Baker”。更改引用是可能的，因为您通过ref关键字传递了它(=>是对字符串引用的引用)。 第二个调用获取字符串引用的副本。

弦一开始看起来很特别。但字符串只是一个引用类，如果你定义

string s = "Able";

那么s是一个包含文本“Able”的字符串类的引用! 对同一个变量via的另一个赋值

s = "Baker";

不改变原来的字符串，但只是创建一个新的实例，让我们指向该实例!

你可以试试下面的小代码示例:

string s = "Able";
string s2 = s;
s = "Baker";
Console.WriteLine(s2);

你想要什么? 您将得到的仍然是“Able”，因为您只是将s中的引用设置为另一个实例，而s2指向原始实例。

编辑: String也是不可变的，这意味着根本没有修改现有字符串实例的方法或属性(你可以尝试在文档中找到一个，但你找不到:-))。所有字符串操作方法都会返回一个新的字符串实例!(这就是为什么你在使用StringBuilder类时经常会得到更好的性能)