为什么不能通过没有'out'的方法来分配Texture2D？

Question

I've got a class that holds a Texture2D like so:

public class TextureData
{
    public Texture2D texture;
}

When I load all of my textures, I handle it through methods like this:

public void LoadAllTextures()
{
    foreach(string s in texturesToBeLoaded)
    {
        TextureData data = new TextureData();
        LoadTexture(s, data.texture);
        // data.texture is still null.
    }
}
public void LoadTexture(string filename, Texture2D texture)
{
    texture = content.Load<Texture2D>(filename);
    // texture now holds the texture information but it doesn't
    // actually retain it when the method ends...why?
}

Am I missing something here? If I change

public void LoadTexture(string filename, Texture2D texture)

To

public void LoadTexture(string filename, out Texture2D texture)

It works fine.

---

EDIT: Alright so the way I understand it now is this...

public void LoadAllTextures()
{
    foreach(string s in texturesToBeLoaded)
    {
        TextureData data = new TextureData();
        // here, data.texture's memory address == 0x0001
        LoadTexture(s, data.texture /*0x0001*/);
    }
}
public void LoadTexture(string filename, Texture2D texture /* this is now 0x0001 */)
{
    texture = content.Load<Texture2D>(filename);
    // now the PARAMETER is set to 0x0002, not data.texture itself.
}

Answer 1

C# passes variables by value - a copy of the reference is passed but the original variable or field remains untouched. Adding out (or ref ) makes it pass by reference, which then causes the original variable/field to be updated.

Answer 2

Lucero's answer is correct - the practical change you would make is to change your methods to work as follows:

public void LoadAllTextures()
{
    foreach(string s in texturesToBeLoaded)
    {
        TextureData data = LoadTexture(s);
        // do something with data here
    }
}

public Texture2D LoadTexture(string filename)
{
    Texture2D texture = content.Load<Texture2D>(filename);
    return texture;
}

Answer 3

That is because you are modifying the copy of the reference. Earlier data.texture points to a memory location suppose 048 , when you call LoadTexture(s, data.texture); the parameter texture now holds the value 048 . In the first line in your method LoadTexture you are assigning it a new memory location, so now texture points to something totally new, but not 048 . That is why you don`t see any change.

But if you update any property of texture , you will see the change in original data as well.

Consider the following case:

public class TempClass
{
    public string MyProperty { get; set; }
}

In your Main method you can do:

TempClass tc = new TempClass();
tc.MyProperty = "Some value";
SomeMethod(tc);

Where as your SomeMethod is:

public static void SomeMethod(TempClass temp)
{
    temp = null;
}

Now that will not set the object tc of TempClass to null.

You should see this article by Jon Skeet: Parameter passing in C#

Answer 4

The confusion probably comes from what it means to pass by reference. In C#, objects are passed by reference. This means if you modify properties of the object in a function, those changes will be reflected in the calling function as well as they both have references to the same object. However, pass-by-reference does NOT mean that if you update the variable to refer to a different object (eg by creating a new object) in the function that the variable in the calling function will be updated to refer to the same object. You must use ref or out if this is the behavior you want.