结构是“按值传递”吗？

Question

我最近尝试为 Vector2 字段创建一个属性，只是意识到它没有按预期工作。

public Vector2 Position { get; set; }

这使我无法更改其成员的值 (X & Y)

查找这方面的信息，我读到为Vector2 结构创建属性仅返回原始对象的副本而不是引用。

作为一名 Java 开发人员，这让我很困惑。

C#中的对象什么时候传值，什么时候传引用？
所有的struct对象都是传值吗？

Answer 1

struct 是一个值类型，所以它总是作为值传递。

值可以是引用类型（对象）或值类型（结构）。传递的总是一个值；对于引用类型，您将引用的值传递给它，对于值类型，您将值本身传递。

当您使用ref 或out 关键字传递参数时，使用术语引用。然后，您将传递对包含该值的变量的引用，而不是传递该值。通常，参数总是按值传递。

Answer 2

对象通过引用传递，结构通过值传递。但请注意，参数上有“out”和“ref”修饰符。

所以你可以像这样通过引用传递一个结构：

public void fooBar( ref Vector2 position )
{
}

Answer 3

问题是，getter 返回Vector2 的副本。如果你像这样改变坐标

obj.Position.X = x;
obj.Position.Y = y;

您只更改此临时副本的坐标。

改为这样做

obj.Position = new Vector2(x, y);

---

这与按值或按引用无关。 Value2 是一个值类型，get 返回这个值。如果向量具有引用类型（类），get 将返回此引用。 return 按值返回值。如果我们有一个引用类型，那么这些引用就是值并被返回。

Answer 4

是的，结构继承自 ValueType，并按值传递。这对于原始类型也是如此 - int、double、bool 等（但不是字符串）。 字符串、数组和所有的类都是引用类型，都是通过引用传递的。

如果你想通过 ref 传递一个结构，使用 ref 关键字：

public void MyMethod (ref Vector2 position)

它将通过引用传递结构，并允许您修改其成员。

Answer 5

重要的是要意识到everything in C# is passed by value，除非您在签名中指定ref 或out。

值类型（以及 structs）与引用类型的不同之处在于，值类型是直接访问的，而引用类型是通过其引用访问的。如果将引用类型传递给方法，它的引用，而不是值本身，是按值传递的。

为了说明，假设我们有一个 class PointClass 和一个 struct PointStruct，定义类似（省略不相关的细节）：

struct PointStruct { public int x, y; }

class PointClass { public int x, y; }

我们有一个方法SomeMethod，按值接受这两种类型：

static void ExampleMethod(PointClass apc, PointStruct aps) { … }

如果我们现在创建两个对象并调用方法：

var pc = new PointClass(1, 1);
var ps = new PointStruct(1, 1);

ExampleMethod(pc, ps);

……我们可以用下图来形象化：

由于pc 是一个引用，它本身不包含值；相反，它引用了内存中其他地方的（未命名的）值。这通过虚线边框和箭头可视化。

但是：对于pc 和ps，在调用方法时会复制实际变量。

如果ExampleMethod 在内部重新分配参数变量会怎样？让我们检查一下：

static void ExampleMethod(PointClass apc, PointStruct aps); {
    apc = new PointClass(2, 2);
    aps = new PointStruct(2, 2);
}

调用方法后pc和ps的输出：

pc: {x: 1, y: 1}
ps: {x: 1, y: 1}

→ ExampleMethod 更改了值的副本，原始值不受影响。

从根本上说，这就是“按价值传递”的意思。

引用类型和值类型之间仍然存在差异，这在修改值的成员时起作用，而不是变量本身。当人们面对引用类型是按值传递的事实时，这是使人们绊倒的部分。考虑一个不同的ExampleMethod。

static void ExampleMethod(PointClass apc, PointStruct aps) {
    apc.x = 2;
    aps.x = 2;
}

现在我们在调用方法后观察到如下结果：

pc: {x: 2, y: 1}
ps: {x: 1, y: 1}

→ 引用对象改变了，而值对象没有改变。上图说明了原因：对于引用对象，即使复制了pc，pc 和apc 引用的实际值仍然相同，我们可以通过apc 对其进行修改。至于ps，我们将实际值本身复制到aps； ExampleMethod无法触及原始值。

Answer 6

.NET 数据类型分为 value 和 reference 类型。值类型包括int、byte 和structs。引用类型包括string 和类。

当结构体只包含一种或两种值类型时，结构体代替类是合适的（尽管即使在那里你也可能产生意想不到的副作用）。

所以结构确实是按值传递的，你看到的是预期的。

Answer 7

结构类型的每个存储位置都包含该结构的所有字段，私有的和公共的。传递结构类型的参数需要在堆栈上为该结构分配空间，并将结构中的所有字段复制到堆栈。

关于使用存储在集合中的结构，在现有集合中使用可变结构通常需要将结构读取到本地副本，改变该副本，然后将其存储回来。假设 MyList 是一个List<Point>，并且想在MyList[3].X 中添加一些局部变量z：

点 temp = MyList[3]; 温度.X += Z; 我的列表 [3] = 温度；

这有点烦人，但通常比使用不可变结构更清洁、更安全、更高效，比不可变类对象更有效，比使用可变类对象更安全。我真的很想看到编译器支持以更好的方式让集合公开值类型元素。有一些方法可以编写高效的代码来处理这种具有良好语义的暴露（例如，集合对象可以在元素更新时做出反应，而不需要这些元素与集合有任何链接），但代码读起来很糟糕。以在概念上类似于闭包的方式添加编译器支持将使高效的代码也具有可读性。

请注意，与某些人声称的相反，结构与类类型对象根本不同，但对于每个结构类型都有一个对应的类型，有时称为“盒装结构” "，它派生自 Object（参见 the CLI (Common Language Infrastructure) specification，第 8.2.4 和 8.9.7 节）。尽管编译器会在必要时将任何结构隐式转换为其相应的装箱类型，以将其传递给期望引用类类型对象的代码，但允许对装箱结构的引用将其内容复制到真实结构中，并且有时会允许直接使用盒装结构的代码，盒装结构的行为类似于类对象，因为它们就是这样。

Answer 8

只是为了说明通过方法传递struct和class的不同效果：

（注意：在LINQPad 4 测试）

示例

/// via http://stackoverflow.com/questions/9251608/are-structs-pass-by-value
void Main() {

    // just confirming with delegates
    Action<StructTransport> delegateTryUpdateValueType = (t) => {
        t.i += 10;
        t.s += ", appended delegate";
    };

    Action<ClassTransport> delegateTryUpdateRefType = (t) => {
        t.i += 10;
        t.s += ", appended delegate";
    };

    // initial state
    var structObject = new StructTransport { i = 1, s = "one" };
    var classObject = new ClassTransport { i = 2, s = "two" };

    structObject.Dump("Value Type - initial");
    classObject.Dump("Reference Type - initial");

    // make some changes!
    delegateTryUpdateValueType(structObject);
    delegateTryUpdateRefType(classObject);

    structObject.Dump("Value Type - after delegate");
    classObject.Dump("Reference Type - after delegate");

    methodTryUpdateValueType(structObject);
    methodTryUpdateRefType(classObject);

    structObject.Dump("Value Type - after method");
    classObject.Dump("Reference Type - after method");

    methodTryUpdateValueTypePassByRef(ref structObject);
    methodTryUpdateRefTypePassByRef(ref classObject);

    structObject.Dump("Value Type - after method passed-by-ref");
    classObject.Dump("Reference Type - after method passed-by-ref");
}

// the constructs
public struct StructTransport {
    public int i { get; set; }
    public string s { get; set; }
}
public class ClassTransport {
    public int i { get; set; }
    public string s { get; set; }
}

// the methods
public void methodTryUpdateValueType(StructTransport t) {
    t.i += 100;
    t.s += ", appended method";
}

public void methodTryUpdateRefType(ClassTransport t) {
    t.i += 100;
    t.s += ", appended method";
}

public void methodTryUpdateValueTypePassByRef(ref StructTransport t) {
    t.i += 1000;
    t.s += ", appended method by ref";
}

public void methodTryUpdateRefTypePassByRef(ref ClassTransport t) {
    t.i += 1000;
    t.s += ", appended method by ref";
}

结果

（来自 LINQPad 转储）

Value Type - initial 
StructTransport 
UserQuery+StructTransport 
i 1 
s one 


Reference Type - initial 
ClassTransport 
UserQuery+ClassTransport 
i 2 
s two 

//------------------------

Value Type - after delegate 
StructTransport 
UserQuery+StructTransport 
i 1 
s one 


Reference Type - after delegate 
ClassTransport 
UserQuery+ClassTransport 
i 12 
s two, appended delegate 

//------------------------

Value Type - after method 
StructTransport 
UserQuery+StructTransport 
i 1 
s one 


Reference Type - after method 
ClassTransport 
UserQuery+ClassTransport 
i 112 
s two, appended delegate, appended method 

//------------------------

Value Type - after method passed-by-ref 
StructTransport 
UserQuery+StructTransport 
i 1001 
s one, appended method by ref 


Reference Type - after method passed-by-ref 
ClassTransport 
UserQuery+ClassTransport 
i 1112 
s two, appended delegate, appended method, appended method by ref 

Answer 9

前言：C# 虽然托管仍然具有 C 创建的核心内存习惯用法。内存可以合理地视为一个巨大的数组，其中数组中的索引被标记为“内存地址”。 指针 是该数组的数字索引，也称为内存地址。该数组中的值可以是数据，也可以是指向另一个内存地址的指针。 const 指针 是存储在此数组中某个无法更改的索引处的值。内存地址本来就存在并且永远不会改变，但是如果它是 not const，则位于该地址的值总是可以改变。

通过类

类/引用类型（包括字符串）由 const 指针引用传递。突变将影响此实例的所有用法。您不能更改对象的地址。如果您尝试使用赋值或new 更改地址，您实际上将创建一个与当前范围内的参数同名的局部变量。

通过副本传递

Primitives / ValueTypes / structs（字符串都不是，即使它们不诚实地伪装成它们）在从方法、属性返回或作为参数接收时会被完全复制。结构的突变永远不会被共享。如果结构包含类成员，则复制的是指针引用。这个成员对象是可变的。

基元永远不可变。不能将 1 变异为 2，可以将当前引用 1 的内存地址变异为当前作用域内 2 的内存地址。

通过true引用

需要使用out 或ref 关键字。

ref 将允许您更改指针 new 对象或分配现有对象。 ref 还允许您通过其内存指针传递原始/ValueType/结构以避免复制对象。如果您分配给它，它还允许您替换指向不同原语的指针。

out 在语义上与ref 相同，但有一点不同。 ref 参数需要初始化，out 参数允许未初始化，因为它们需要在接受参数的方法中进行初始化。这通常显示在 TryParse 方法中，并且当 x 的初始值不起作用时，您无需拥有 int x = 0; int.TryParse("5", out x)。