blocks|key|3134512|text|这里的问题是，这实际上是两个问题-一个问题是关于继承，在这种情况下，答案是“几乎一切”，另一个是关于引用类型与值类型/内存/装箱，在这种情况下，答案是“否”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3134513|继承：|offset|length|style|BOLD|3134514|在C#中，以下情况成立：|3134515|3134516|所有的值类型，包括枚举和可空类型，都是从System.Object派生的。所有类、数组和委托类型都派生自System.Object.|unordered-list-item|CODE|3134517|Interface类型，而不是派生自|3134518|。它们都可以转换为System.Object，但接口只能派生自其他接口类型，而System.Object不是接口类型。没有从System.Object派生的指针类型，也不能直接转换为System.Object.|3134519|"Open“类型参数类型也不是从System.Object派生的。类型参数类型不是从任何东西派生的；类型参数被约束为从有效的基类派生，但它们本身并不是从任何东西“派生”的。|3134520|3134521|来自the+MSDN+entry+for+System.Object|3134522|3134523|支持.NET框架类层次结构中的所有类，并为派生类提供低级服务。这是.NET框架中所有类的最终基类；它是类型层次结构的根。|blockquote|3134524|3134525|语言通常不需要类来声明从Object继承，因为继承是隐式的。|3134526|因为.NET框架中的所有类都是从Object派生的，所以在Object类中定义的每个方法在系统中的所有对象中都可用。派生类可以而且确实会重写其中的一些方法。|3134527|3134528|因此，并不是C#中的每种类型都是从System.Object派生的。即使对于这些类型，您仍然需要注意reference+types和value+types之间的区别，因为它们的处理方式非常不同。|3134529|拳击：|3134530|虽然值类型确实继承自System.Object，但它们在内存中的处理方式与引用类型不同，并且它们在代码中如何通过方法传递的语义也不同。实际上，值类型不会被视为对象(引用类型)，直到您通过将值类型包装为引用类型来显式指示应用程序这样做。参见more+information+about+boxing+in+C#+here。|3134531|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.object.aspx|1|http://msdn.microsoft.com/en-us/library/490f96s2.aspx|2|http://msdn.microsoft.com/en-us/library/s1ax56ch.aspx|3|http://msdn.microsoft.com/en-us/library/yz2be5wk.aspx^0|0|0|3|0|0|0|K|D|1G|D|0|0|9|D|13|D|1Q|D|2J|D|0|G|D|0|0|2|W|0|0|0|0|0|0|0|0|H|D|1E|F|1|1U|B|2|0|0|3|0|A|D|3B|14|3|0^^$0|@$1|2|3|4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1S|8|@$D|1T|E|1U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1V|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1X|8|@$D|1Y|E|1Z|F|N]|$D|20|E|21|F|N]]|9|@]|A|$]]|$1|O|3|P|5|M|7|22|8|@]|9|@]|A|$]]|$1|Q|3|R|5|M|7|23|8|@$D|24|E|25|F|N]|$D|26|E|27|F|N]|$D|28|E|29|F|N]|$D|2A|E|2B|F|N]]|9|@]|A|$]]|$1|S|3|T|5|M|7|2C|8|@$D|2D|E|2E|F|N]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2G|8|@]|9|@$D|2H|E|2I|1|2J]]|A|$]]|$1|X|3|-4|5|6|7|2K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|10|7|2L|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2N|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2O|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2Q|8|@$D|2R|E|2S|F|N]]|9|@$D|2T|E|2U|1|2V]|$D|2W|E|2X|1|2Y]]|A|$]]|$1|19|3|1A|5|6|7|2Z|8|@$D|30|E|31|F|G]]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|32|8|@$D|33|E|34|F|N]]|9|@$D|35|E|36|1|37]]|A|$]]|$1|1D|3|-4|5|6|7|38|8|@]|9|@]|A|$]]]|1E|$1F|$5|1G|1H|1I|A|$1J|1K]]|1L|$5|1G|1H|1I|A|$1J|1M]]|1N|$5|1G|1H|1I|A|$1J|1O]]|1P|$5|1G|1H|1I|A|$1J|1Q]]]]

The problem here is that this is really two questions - one question is about inheritance, in which case the answer is "nearly everything", and the other is about reference type vs value type/memory/boxing, which case the answer is "no".

Inheritance:

In C#, the following is true:

<ul>
<li>All value types, including enums and nullable types, are derived from <code>System.Object</code>. </li>
<li>All class, array, and delegate types are derived from <code>System.Object</code>.</li>
<li>Interface types are not derived from <code>System.Object</code>. They are all convertible to <code>System.Object</code>, but interfaces only derive from other interface types, and <code>System.Object</code> is not an interface type. </li>
<li>No pointer types derive from <code>System.Object</code>, nor are any of them directly convertible to <code>System.Object</code>.</li>
<li>"Open" type parameter types are also not derived from <code>System.Object</code>. Type parameter types are not derived from anything; type arguments are constrained to be derived from the effective base class, but they themselves are not "derived" from anything.</li>
</ul>

From <a href="http://msdn.microsoft.com/en-us/library/system.object.aspx" rel="noreferrer">the MSDN entry for System.Object</a>:

<blockquote>
 Supports all classes in the .NET
 Framework class hierarchy and provides
 low-level services to derived classes.
 This is the ultimate base class of all
 classes in the .NET Framework; it is
 the root of the type hierarchy.
 
 Languages typically do not require a
 class to declare inheritance from
 Object because the inheritance is
 implicit.
 
 Because all classes in the .NET
 Framework are derived from Object,
 every method defined in the Object
 class is available in all objects in
 the system. Derived classes can and do
 override some of these methods.
</blockquote>

So not every type in C# is derived from <code>System.Object</code>. And even for those types that are, you still need to note the difference between <a href="http://msdn.microsoft.com/en-us/library/490f96s2.aspx" rel="noreferrer">reference types</a> and <a href="http://msdn.microsoft.com/en-us/library/s1ax56ch.aspx" rel="noreferrer">value types</a>, as they are treated very differently.

Boxing:

While value types do inherit from <code>System.Object</code>, they are treated differently in memory from reference types, and the semantics of how they are passed through methods in your code are different as well. Indeed, a value type is not treated as an Object (a reference type), until you explicitly instruct your application to do so by boxing it as a reference type. See <a href="http://msdn.microsoft.com/en-us/library/yz2be5wk.aspx" rel="noreferrer">more information about boxing in C# here</a>.

blocks|key|3134552|text|根据我读过的所有书籍，C#中的所有内容都是对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3134553|一些是引用，另一些是值类型。值类型对象继承自类ValueType。它们有不同的行为，但本质上...对象。|offset|length|3134554|这就是为什么可以在对象变量中存储Int32以及可以在.NET中创建的所有内容的原因。|3134555|更多细节...查看以下内容：http://msdn.microsoft.com/en-us/library/s1ax56ch(VS.71).aspx|3134556|3134557|所有值类型都隐式派生自Object类。|blockquote|3134558|3134559|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.valuetype.aspx|1|http://msdn.microsoft.com/en-us/library/s1ax56ch(VS.71).aspx^0|0|N|9|0|0|0|E|1O|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|19|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Based on all books that I read, everything in C# is an object.

Some are reference other are Value type. Value type object inherit from the class <a href="http://msdn.microsoft.com/en-us/library/system.valuetype.aspx" rel="nofollow noreferrer">ValueType</a>. They have different behavior but inherently ... objects.

This is the reason why you can store an Int32 in an object variable as well as everything that you can ever create in .NET.

For more detail... look at the following: <a href="http://msdn.microsoft.com/en-us/library/s1ax56ch(VS.71).aspx" rel="nofollow noreferrer">http://msdn.microsoft.com/en-us/library/s1ax56ch(VS.71).aspx</a>

<blockquote>
 All value types are derived implicitly
 from the Object class.
</blockquote>

blocks|key|356045|text|值类型不是对象，它们遵循不同的复制语义和传递语义，并且必须包装在类(对象)中才能被视为对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356046|编辑:我认为这个论点有点模糊，因为你必须限定你所说的“对象”是什么意思。对象是继承自对象的东西，还是服从对象的使用语义的东西？或者我们谈论的是对象的最一般的定义，它是任何可以包含数据和对数据的操作的东西？|356047|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Value types are not objects, they obey different copying semantics, different passing semantics, and must be wrapped in a class (Object) in order to be treated as such.

Edit: I think the argument is somewhat vague, as you must qualify what you mean by 'object'. Is an object just something that inherits from Object, or is it something that obeys Object's use semantics? Or are we talking the most general definition of object, where it is anything that can contain data and operations on that data?

blocks|key|353525|text|数字2不是对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|353526|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

blocks|key|352283|text|您正在将对象与值或引用相混淆。基本上，一切都是对象。Int是一个对象，但它也是一个值类型。类实例是一个对象，但它也是一个引用类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|352284|方法不是对象，属性也不是。只是对对象进行操作。是的，几乎所有的东西都继承自object类。|352285|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You're confusing an object with a value or reference. Basically, everything is an object. An Int is an object, but it is also a value type. A class instance is an object, but it is also a reference type.

Methods aren't objects, nor are properties. The just operate on objects. And yes, pretty much everything inherits from the object class.

blocks|key|3347664|text|我认为值类型不是对象。它们通过CLR以不同的方式存储在内存中-值类型存储在堆栈上，而对象存储在堆上。您可以将值类型强制转换为引用类型，以使其行为类似于对象，但CLR将值从堆栈中取出，将其包装在对象中，并将其存储在堆中。这就是当你“装箱”一个变量时发生的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3347665|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I thought that value types are NOT objects. They're stored differently in memory by the CLR - value types are stored on the stack, and objects are stored on the heap. You can cast value types to a reference type to make them act like an object, but the CLR takes the value off of the stack, wraps it in an object, and stores it on the heap. That is what happens when you "box" a variable.

blocks|key|352381|text|它们都被视为对象，但它们并不都是对象。Autoboxing带来了混乱。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|352382|有关更多信息，请参阅：http://en.wikipedia.org/wiki/Object_type|offset|length|352383|这种抽象显然会让人感到困惑。|352384|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Object_type^0|0|B|14|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

They are all treated as objects, but they are not all objects. The confusion comes in with Autoboxing. 

See this for more information: <a href="http://en.wikipedia.org/wiki/Object_type" rel="noreferrer">http://en.wikipedia.org/wiki/Object_type</a>

The abstraction confuses people apparently.

blocks|key|3134902|text|在C#+(以及一般的OOP+)中，我们有类型(类引用、结构值等)。这些是定义。而“对象”是给定类型的具体实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3134903|所以，如果我们从字面上读这个问题，是的，在实例化时一切都是一个对象。|3134904|混淆很可能始于对所有东西的基类名称的错误选择。在.NET中，这是Object类。|offset|length|3134905|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/.NET_Framework^0|0|0|O|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

In C# (and in OOP in general) we have types (class - reference, struct - value, etc.). These are the definitions. And the "object" is the concrete instance of a given type.

So, if we read the question literally, yes, everything is an object when instantiated.

The confusion most probably begins with a bad choosing of the name of the very base class for everything. In <a href="http://en.wikipedia.org/wiki/.NET_Framework" rel="nofollow noreferrer">.NET</a> this is the Object class.

blocks|key|352398|text|这里的一些人对面向对象编程中的“对象”有一个奇怪的概念。为了使某个对象成为对象，它不必是引用类型，或者更一般地说，遵循任何正式的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|352399|这意味着在面向对象的世界中，您可以作为一等公民对其进行操作。由于您可以对C#中的值执行此操作(感谢自动装箱)，因此一切都确实是一个对象。在某种程度上，这甚至适用于函数(但可以说不适用于类)。|352400|这在实践中是否相关是另一个问题，但这是我再次注意到的OOP的一个普遍问题。没有人清楚OOP的定义(是的，大多数人都认为它与多态性、继承和封装有关，有些人为了更好地衡量而加入了“抽象”)。|352401|从使用的角度来看，C#中的每个值都像一个对象一样处理。也就是说，我喜欢目前被接受的答案。它提供了两个重要的技术方面。|352402|请注意，在其他上下文中，例如C%2B%2B，强调其他方面，因为C%2B%2B不一定是面向对象的，而且更多地关注低级方面。因此，对象、POD和内置原语之间的区别有时是有意义的(但有时又不是)。|352403|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Some people here have a strange notion of what an “object” in object-oriented programming is. In order for something to be an object it does not have to be a reference type or, more generally, follow any formal implementation.

All that means is that you can operate on it as a first-class citizen in an object-oriented world. Since you can do this on values in C# (thanks to autoboxing), everything is indeed an object. To some extend, this is even true for functions (but arguably not for classes).

Whether this is relevant in practice is another question but this is a general problem with OOP that I notice once again. Nobody is clear on the definition of OOP (yes, most people agree that it has something to do with polymorphism, inheritance and encapsulation, some throw in “abstraction” for good measure).

From a usage point of view, every value in C# handles like an object. That said, I like the currently accepted answer. It offers both technically important aspects.

Notice that in other contexts, e.g. C++, other aspects are stressed since C++ isn't necessarily object-oriented and furthermore is much more focused on low-level aspects. Therefore, the distinction between objects, POD and builtin primitives makes sometimes sense (then again, sometimes not).

blocks|key|3347832|text|来自：Value+Types+(C#+Reference)+-+MSDN+3.5|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3347833|3347834|所有值类型都隐式派生自System.ValueType。|blockquote|3347835|3347836|3347837|来自：Value+Type+Class+-+MSDN+3.5|3347838|3347839|+ValueType用更合适的值类型实现覆盖了Object中的虚方法。|3347840|3347841|3347842|来自：Enum+Class+-+MSDN+3.5|3347843|3347844|此类从ValueType继承|3347845|3347846|3347847|继承层次结构如下：|3347848|3347849|System.Object+|unordered-list-item|3347850|System.ValueType+|3347851|System.Enum|3347852|3347853|3347854|3347855|​|3347856|3347857|结论：Everything+is+a+object|style|BOLD|3347858|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/s1ax56ch.aspx|1|http://msdn.microsoft.com/en-us/library/system.valuetype.aspx|2|http://msdn.microsoft.com/en-us/library/system.enum.aspx^0|3|11|0|0|0|0|0|0|3|R|1|0|0|0|0|0|3|L|2|0|0|0|0|0|0|0|1|2|2|1|0|0|0|0|3|M|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@$A|1U|B|1V|1|1W]]|C|$]]|$1|D|3|-4|5|6|7|1X|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1Y|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|20|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|21|8|@]|9|@$A|22|B|23|1|24]]|C|$]]|$1|L|3|-4|5|6|7|25|8|@]|9|@]|C|$]]|$1|M|3|N|5|G|7|26|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|27|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|28|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|29|8|@]|9|@$A|2A|B|2B|1|2C]]|C|$]]|$1|S|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]|$1|T|3|U|5|G|7|2E|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|2F|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|2G|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|2H|8|@]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]|$1|10|3|11|5|12|7|2J|8|@]|9|@]|C|$]]|$1|13|3|14|5|12|7|2K|8|@]|9|@]|C|$]]|$1|15|3|16|5|12|7|2L|8|@]|9|@]|C|$]]|$1|17|3|-4|5|6|7|2M|8|@]|9|@]|C|$]]|$1|18|3|-4|5|6|7|2N|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|2O|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|6|7|2P|8|@]|9|@]|C|$]]|$1|1C|3|1B|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|6|7|2R|8|@$A|2S|B|2T|1F|1G]]|9|@]|C|$]]|$1|1H|3|-4|5|6|7|2U|8|@]|9|@]|C|$]]]|1I|$1J|$5|1K|1L|1M|C|$1N|1O]]|1P|$5|1K|1L|1M|C|$1N|1Q]]|1R|$5|1K|1L|1M|C|$1N|1S]]]]

From: <a href="http://msdn.microsoft.com/en-us/library/s1ax56ch.aspx" rel="nofollow noreferrer">Value Types (C# Reference) - MSDN 3.5</a>

<blockquote>
 All value types are derived implicitly
 from the System.ValueType.
</blockquote>

From: <a href="http://msdn.microsoft.com/en-us/library/system.valuetype.aspx" rel="nofollow noreferrer">Value Type Class - MSDN 3.5</a>

<blockquote>
 ValueType overrides the virtual
 methods from Object with more
 appropriate implementations for value
 types.
</blockquote>

From: <a href="http://msdn.microsoft.com/en-us/library/system.enum.aspx" rel="nofollow noreferrer">Enum Class - MSDN 3.5</a>

<blockquote>
 This class inherits from ValueType
</blockquote>

The Inheritance Hierarchy is as follows:

<ul><li>System.Object
<ul><li>System.ValueType
<ul><li>System.Enum</li></li></li></ul></ul></ul>

Conclusion: Everything is an object

blocks|key|352431|text|考虑到问题是指OOP意义上的对象，答案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|352432|从技术的角度来看，答案是：No|offset|length|style|BOLD|352433|从教条的观点来看，答案是：是|352434|解释：|352435|从技术上讲，值类型(原语或结构)不是对象，除非是“装箱”形式，但因为.Net通过装箱/拆箱(创建一个保存值并从Object派生的类实例)将值类型无缝地转换为对象对应物，这意味着值类型既可以被视为对象，也可以被视为简单的值。|352436|因此，值类型在本质上是双重的，它们的行为类似于值和对象。.Net中的值在需要时是对象，而在其余情况下不是对象。|352437|考虑到技术方面的正确答案是“.Net中的一切都是，就好像它是一个对象一样”。|352438|教条式的回答是“一切都是对象”。|352439|entityMap^0|0|1|2|D|2|0|1|3|D|1|0|0|0|N|1|P|2|0|O|6|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|U|$]]

Considering that the question is referring to Object in a OOP sense, the answers is:

From a technical point of view the answer is: No

From a dogmatic point of view the answer is: Yes

Explanation:

Technically value types (primitives or structs) are not objects unless in "boxed" form, but because the .Net does seamless conversions of value types to their Object counterpart through the act of boxing/unboxing (creating a class instance that holds the value and is derived from Object) that means value types can be treated as both objects and simple values.

So value types are dual in nature, they behave as values and as objects. Values in .Net are Objects when they need to be, and they are not objects in the rest of cases.

The correct answer that takes the technical aspect into consideration is "Everything in .Net is as if it were an Object".

The dogmatic answer is "Everything is an Object".

blocks|key|3135034|text|简短的回答：No。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3135035|答案取决于“对象”的定义。不同的语言对什么是“对象”-means有不同的定义，但C#的权威定义是官方C#+Language+Specification|3135036|3135037|+C#语言的类型主要分为两类：引用类型和值类型。(...)值类型与引用类型的不同之处在于，值类型的变量直接包含它们的数据，而引用类型的变量存储对其数据的对象引用，后者称为。|blockquote|3135038|3135039|3135040|因此，根据C#，对象是引用类型的实例。因此，值类型值不是对象。因此，在C#中，并不是所有东西都是对象。|3135041|但是：|3135042|3135043|+C#的类型系统是统一的，因此任何类型的值都可以被视为对象。(...)通过执行装箱和取消装箱操作，值类型的值被视为对象(§9.3.12)。|3135044|3135045|3135046|因此，值类型可以通过装箱将其视为对象(有效地转换为引用类型)。但未装箱的值类型本身并不是对象。|3135047|CLR+Specification+PDF使用与C#非常相似的定义：|3135048|3135049|+object：引用类型的实例。一个对象不仅仅是一个值。对象是自类型的；它的类型显式地存储在它的表示中。它有一个区别于所有其他对象的标识，并且它有存储其他实体(可以是对象或值)的槽。虽然它的槽的内容可以改变，但对象的标识永远不会改变。|3135050|3135051|3135052|因此，在CLR术语中，值类型值也不是对象。|3135053|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dotnet/csharplang/blob/main/spec/types.md#types|1|https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf^0|6|2|0|1E|P|0|0|0|F|4|K|3|2D|1|0|0|0|0|1F|0|0|3|0|0|0|1X|0|0|0|0|1B|0|0|Y|0|H|1|0|0|1|38|0|0|0|0|L|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1K|8|@]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|H|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|21|8|@$9|22|A|23|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|24|8|@]|D|@]|E|$]]|$1|S|3|T|5|K|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2D|8|@$9|2E|A|2F|B|C]]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|10|3|-4|5|6|7|2J|8|@]|D|@]|E|$]]|$1|11|3|12|5|K|7|2K|8|@$9|2L|A|2M|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2N|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2O|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|17|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]|1F|$5|1A|1B|1C|E|$1D|1G]]]]

Short answer: No.
The answer hinges on the definition of &quot;object&quot;. Different languages have different definitions of what &quot;object&quot;-means, but the authoritative definition for C# is the official <a href="https://github.com/dotnet/csharplang/blob/main/spec/types.md#types" rel="nofollow noreferrer">C# Language Specification</a>:
<blockquote>
The types of the C# language are divided into two main categories: reference types and value types. (...) Value types differ from reference types in that variables
of the value types directly contain their data, whereas variables of
the reference types store references to their data, the latter being
known as objects.
</blockquote>
So according to the C#, an object is an instance of a reference type. Value type values are therefore not objects. So it is not true that everything is an object in C#.
However:
<blockquote>
C#’s type
system is unified such that a value of any type can be treated as an
object. (...) Values of value types are treated as objects by
performing boxing and unboxing operations (§9.3.12).
</blockquote>
So a value type can be treated as an object by boxing it (effectively turning into a reference type). But an unboxed value type is not in itself an object.
The <a href="https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf" rel="nofollow noreferrer">CLR Specification</a> [PDF] uses a definition very similar to C#:
<blockquote>
object: An instance of a reference type. An object has more to it than
a value. An object is self-typing; its type is explicitly stored in
its representation. It has an identity that distinguishes it from all
other objects, and it has slots that store other entities (which can
be either objects or values). While the contents of its slots can be
changed, the identity of an object never changes.
</blockquote>
So in the CLR terminology, a value type value is not an object either.

blocks|key|3347975|text|虽然每个人似乎都在关注值类型与引用类型的争论，但我们忘记了C#中的一种类型，它既不是引用也不是值，它不是从object派生的，也不能转换为object：指针。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3347976|与值和引用类型不同，指针不能强制转换为object。|3347977|根据MSDN+documentation+on+C#+pointer+types的说法|3347978|3347979|指针类型不是从object继承的，并且指针类型和object之间不存在转换。此外，装箱和取消装箱不支持指针。但是，您可以在不同的指针类型之间进行转换，也可以在指针类型和整型之间进行转换。|blockquote|3347980|3347981|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/y31yhkeb(VS.80).aspx)^0|24|3|0|0|2|12|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|J|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|15|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

While everyone seems to be focusing on the value types vs. reference types debate, we are forgetting one type in C# that is neither reference nor value, it doesn't derive from object, and it can't be cast to object: pointers.

Unlike values and reference types, pointers cannot be cast to object.

According to the <a href="http://msdn.microsoft.com/en-us/library/y31yhkeb(VS.80).aspx" rel="nofollow noreferrer">MSDN documentation on C# pointer types</a>,

<blockquote>
 Pointer types do not inherit from
 object and no conversions exist
 between pointer types and object.
 Also, boxing and unboxing do not
 support pointers. However, you can
 convert between different pointer
 types and between pointer types and
 integral types.
</blockquote>

blocks|key|356273|text|这是对两个世界的讨论:语言和记忆。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356274|对我来说，语言就像一个抽象层，而术语对象就属于这个抽象层。我看不出从内存组织的角度来讨论对象有什么意义，如果你在谈论内存时确实使用了“对象”这个术语，那么你实际上是从不同的抽象层借用了这个术语。因此，你不应该忘记它的出处。|356275|如果我们谈论的是C#，我不明白为什么有人会使用内存组织作为一个论点。当然，如果我要回答某人这个问题，我会说“是的，在C#中，一切都是对象，但您也应该知道，在幕后，它的工作方式可能会因……而有所不同。”|356276|这可能会引发一个有趣的争论，但也会对一些人说:在类似的讨论中，人们可能会说，实际上没有面向对象的编程，只有过程性编程。你能理解对象吗？更好的是，实际上没有软件，只有不同的硬件状态:)|356277|我的观点是，有些术语无法转换为其他抽象层，您应该将讨论停留在它所属的位置(在这种情况下，它是一种语言，而不是内存)。|356278|甚至这个问题的作者也声明：“请注意，这个问题指的是C#不一定是.NET，以及它是如何在幕后处理数据的(显然都是1和0)。”|356279|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

This a discussion of two worlds: language and memory.

To me language is like a layer of abstraction and the term object belongs to this level of abstraction. I don't see a point in talking about objects in terms of memeory organisation and if you do use the "object" term when talking about memory you actually are borrowing this term from a different layer of abstraction. Thus you shouldn't forget where it came from.

If we're talking about C# I don't undestand why someone would use memory organisation as an argument. Of course if I would answer this question to someone I would say "Yes, in C# everything is an object, but you also should know that under the hood it may work differently depending on...."

This may start an interesting argument but may also speak to some:
in a similar discussion one could say that actually there is no object oriented programming, there's only procedural programming. Does you CPU understand objects?
Even better, actually there is no software, there's only differnt hardware states :)

My point is that some terms don't translate to other layers of abstraction and you should stick the discussion to where it belongs (which in this case is a language, not memory).

Even the author of this question stated: 
"Note that this question refferes to C# not necessarily .NET and how it handles the data under the hood (obviously it's all 1's and 0's.)"

blocks|key|356285|text|在语义方面，当我们已经有了一个完美的、明确的术语来表示->的“引用类型”时，为什么要重载单词"object“，以便它意味着”引用类型“，以及何时，通过以这种方式重载单词"Object”，我们造成了这个线程演示的混乱……即，所有类型(包括值类型)继承在类型"System.Object“中定义的实现的事实之间的不匹配。显然，往好了说，这是没有必要的，往坏了说，这是极其混乱的.即使MS文档有时在这个问题上令人困惑，也不能成为传播混乱的借口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356286|更简单、更清晰的方法是定义和使用术语“对象”来表示任何类型、值或引用的实例，以及短语“引用类型”来描述使用指针变量并将其状态存储在堆中的类型……|356287|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Addressing the semantics, Why overload the word "object" so that it means "reference type" when we already have a perfectly good, unambiguous term for that -> "Reference Type", and the when, by overloading the word "Object" in this way we create the confusion this thread demonstrates... i.e., the mismatch between the fact that all Types, (including value types), inherit the implementation defined in the Type "System.Object". Clearly, this is at best unnecessary, and at worst extremely confusing.. Even the fact that the MS documentation is at times confusing on this issue is no excuse to propagate the confusion.

Much easier, and clearer, is to just define and use the term "object" to mean an instance of ANY type, value or reference, and the phrase "Reference Type" to describe the Types that use pointer variables and have their state stored on the Heap ...

blocks|key|353800|text|有点晚了，但我在SO上的一个搜索结果中发现了这一点，并认为下面的链接会对后代有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|353801|Eric+Lippert+discusses+this+very+thoroughly，用一个更好的(限定的)语句：|offset|length|353802|353803|纠正这个错误的方法是简单地将“源自”替换为“可转换为”，并忽略指针类型:+C#中的每个非指针类型都可以转换为object。|blockquote|353804|353805|353806|如果你讨厌从编写编程语言的人那里读到图文并茂的解释，它的要点是(抛开指针不谈)，像Interface或泛型参数类型声明("T")这样的东西不是对象，但保证在运行时可以作为对象处理，因为它们有一个明确的实例，那将是一个对象。其他类型(类型、枚举、委托、类等)都是对象。包括值类型，它可以被装箱到object，正如其他答案所讨论的那样。|353807|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/ericlippert/archive/2009/08/06/not-everything-derives-from-object.aspx^0|0|D|U|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|11|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

A little late to the party, but I came across this in a search result on SO and figured the link below would help future generations:

Eric Lippert <a href="http://blogs.msdn.com/ericlippert/archive/2009/08/06/not-everything-derives-from-object.aspx" rel="noreferrer">discusses this very thoroughly</a>, with a much better (qualified) statement:

<blockquote>
 The way to correct this myth is to simply replace "derives from" with "is convertible to", and to ignore pointer types: every non-pointer type in C# is convertible to object.
</blockquote>

The gist of it, if you hate reading well-illustrated explanations from people that write programming languages, is that (pointers aside), things like Interface, or generic parameter type declarations ("T") are not objects, but are guaranteed to be treatable as objects at runtime, because they have a definite instance, that will be an Object. Other types (Type, Enum, Delegate, classes, etc.) are all Objects. Including value types, which can be boxed to object as other answers have discussed.

blocks|key|3348196|text|有这么多不同答案的原因之一是这个问题非常不精确。“一切”是什么意思？它真的意味着每一个C#语言元素吗？那么答案显然是“否”：操作符不是对象，"using“关键字不是对象，注释不是对象，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3348197|但如果这不是意思，那又是什么意思呢？也许“除了那些明显不是类的东西之外的所有东西”？这显然没有帮助，因为不同的人对什么是“显而易见”有不同的看法。然而，大多数答案似乎都遵循这种自以为是的解释。|3348198|另一个混淆的来源是“对象”这个术语。什么是对象？这个术语没有唯一的通用定义，不同的人似乎以不同的方式使用它。C#语言中唯一的正式定义是System.Object类型的定义，以及哪些其他类型派生自该类型，哪些不派生。这个文档是现成的，不能再多说了。|3348199|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

One of the reasons why there are so many different answers is that the question is very imprecise. What does &quot;everything&quot; mean? Does it really mean every C# language element? Then the answer is clearly &quot;no&quot;: Operators are not objects, the &quot;using&quot; keyword is not an object, comments are not objects, etc.
But if this was not meant, what was then meant? Maybe &quot;everything apart from those things that are obviously not classes&quot;? This is obviously not helpful as different people have different opinions on what is &quot;obvious&quot;. Nevertheless, most answers seem to follow along this line of opinionated interpretation.
Another source of confusion is around the term &quot;object&quot;. What is an object? There is no unique universal definition of this term and different people seem to use it in a different way. The only formal definition in the C# language is the definition of the System.Object type and which other types derive from it and which not. This documentation is readily available and more can't be said about it.

Please help us settle the controversy of "Nearly" everything is an object (<a href="https://stackoverflow.com/questions/436079/as-a-novice-is-there-anything-i-should-beware-of-before-learning-c#436092">an answer to Stack Overflow question As a novice, is there anything I should beware of before learning C#?</a>). I thought that was the case as everything in Visual Studio at least appears as a struct. Please post a reference, so that it doesn't become "modern jackass" (<a href="http://en.wikipedia.org/wiki/This_American_Life" rel="noreferrer">This American Life</a>).

Note that this question refers to C#, not necessarily .NET, and how it handles the data under the hood (obviously it's all 1's and 0's).

Here are the comments to "everything is an object":

<ul>
<li>Eh, no, it's not. – Binary Worrier</li>
<li>I'd like an example... – scotty2012</li>
<li>isn't everything derived from the
base type Object? – rizzle</li>
<li>Most things are objects... – Omar
Kooheji</li>
<li>Value types, ints, doubles, object
references (not the objects them
selves) etc aren't objects. They can
be "boxed" to look like objects (e.g.
i.ToString()) but really they're
primitive types. Change the entry to
"NEARLY everthing is an object" and
I'll remove the downvote – Binary
Worrier</li>
<li>I appreciate the clarification. I
think the lowest level that you can
interact with, say an int, in C# is
as a struct, which isn't an object? -
<a href="http://msdn.microsoft.com/en-us/library/ms173109.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/library/ms173109.aspx</a>
– rizzle</li>
<li>Doesn't Int32 inherit from ValueType
which inherits from Object? If so,
despite the behavior, an int is an
object. – Chris Farmer</li>
<li>No, the boxed type for int inherits
from ValueType, which inherits from
Object. They're not objects in the
traditional sense because a) an int
isn't a reference to an int, IT IS
the int. b) ints aren't garbage
collected. If you declare an Int32,
then that int is 4 bytes on the
stack, end of story – Binary Worrier</li>
</ul>

Definition of object: "Object" as a inheritor of class System.Object vs. "object" as an instance of a type vs. "object" as a reference type."

Is everything in .NET an object?

Visual Studio

对象存储

请帮助我们解决“几乎”一切都是对象()的争议。我认为情况就是这样，因为Visual Studio中的所有东西至少看起来都是一个结构。请发一个推荐信，这样它就不会变成“现代笨蛋”()了。请注意，这个问题指的是C#，而不一定是.NET，以及它如何在幕后处理数据(显然都是1和0)。下面是对“一切都是对象”的评论：Eh，不，不...

问.NET中的所有东西都是对象吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的所有东西都是对象吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的所有东西都是对象吗？
EN