拳击会在 .NET 中产生垃圾吗？

发布于 2024-08-20 13:37:13 字数 576 浏览 10 评论 0原文

我想知道在对象中装箱值类型是否是一种特殊情况，或者在删除对它的任何引用后，.NET 构造的“盒子”是否会变成垃圾（GC 必须收集的垃圾）。

例如， StringBuilder.AppendFormat() 具有以下重载：

StringBuilder.AppendFormat(string format, object arg0);
StringBuilder.AppendFormat(string format, object arg0, object arg1);
StringBuilder.AppendFormat(string format, object arg0, object arg1, object arg2);
StringBuilder.AppendFormat(string format, params object[] args);

对具有 3 个或更少参数的调用进行这些额外重载可能表明装箱确实是一种特殊情况（或者从性能的角度来看，它值得避免）数组构造）。

理论上，使用普通的旧引用计数（可能带有一组可重用框）将是一种有效的实现，因为不能有从一个框到另一个框的引用，只能从 .NET 对象到一个框的引用。

原文

I'm wondering whether boxing a value type in an object is a special case or whether the "box" constructed by .NET becomes garbage (that the GC has to collect) after any references to it are dropped.

For example, StringBuilder.AppendFormat() has these overloads:

StringBuilder.AppendFormat(string format, object arg0);
StringBuilder.AppendFormat(string format, object arg0, object arg1);
StringBuilder.AppendFormat(string format, object arg0, object arg1, object arg2);
StringBuilder.AppendFormat(string format, params object[] args);

Having those additional overloads for calls with 3 or fewer arguments might indicate that boxing indeed is a special case (or that it pays off, from a performance point-of-view, to avoid array construction).

Theoretically, using plain old reference counting, possibly with a pool of reusable boxes would be a valid implementation because there can be no references from one box to another, only from .NET objects to a box.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

美胚控场 2024-08-27 13:37:13

首先，澄清一下：创建对象引用数组不是装箱。 “拳击”是一个在 .NET 中具有非常具体含义的术语，我认为值得坚持使用它。

装箱确实会产生垃圾，或者更确切地说，每次装箱时，它都会创建一个新对象，该对象最终可能会变成垃圾。（它不必成为垃圾 - 您可能在应用程序的剩余生命周期中拥有对该对象的引用；这种情况非常罕见。）

但是，您可以有一个用于装箱目的的缓存。事实上，Java 确实适合少数人。如果你写：

Integer x = 5;
Integer y = 5;
System.out.println(x == y); // Reference comparison

那么就保证打印true。

但是，这只是一组固定类型的小型缓存 - 它不是通用缓存。您需要平衡通用缓存与弱引用的痛苦（不是引用计数 - .NET 中的 GC 机制只是不引用计数，并且您无法真正引入该对于装箱值来说）几乎肯定会比装箱产生垃圾的小成本对性能造成的影响更大。

.NET可以采用与 Java 相同的方法，并对某些类型的某些值进行装箱，但我不确定是否值得额外的概念性包袱——特别是当平台支持自定义值类型时（Java 不支持）。

值得注意的是，自 .NET 2.0 以来，拳击比以前少了一些。这种情况在数据绑定和反射中经常发生，但现在在普通的旧数据操作中不太常见。

First off, just to clarify: creating an array of object references is not boxing. "Boxing" is a term with a very specific meaning in .NET, and I think it's worth sticking to it.

Boxing does create garbage - or rather, each time you box, it creates a new object which is likely to eventually become garbage. (It doesn't have to become garbage - you might have a reference to that object for the rest of the app's lifetime; it's just pretty rare.)

However, you could have a cache for boxing purposes. Indeed, Java does for small numbers. If you write:

Integer x = 5;
Integer y = 5;
System.out.println(x == y); // Reference comparison

then that's guaranteed to print true.

However, that's just a small cache for a fixed set of types - it's not a general purpose cache. You need to balance the pain of having a general cache with weak references (not reference counting - the GC mechanism in .NET just isn't reference counted, and you couldn't really introduce that just for boxed values) would almost certainly hurt performance more than the small cost of boxing creating garbage.

.NET could have taken the same approach as Java and boxed some values of some types, but I'm not sure it's worth the extra conceptual baggage - especially when the platform supports custom value types (which Java doesn't).

It's probably worth noting that since .NET 2.0, boxing is somewhat rarer than it used to be. It happens a fair amount in data binding and reflection, but it's less common in plain old data manipulation now.

回复收藏 0 原文