Все в .NET является объектом?

Ответ 1

Проблема заключается в том, что на самом деле это два вопроса - один вопрос о наследовании, и в этом случае ответ "почти все", а другой - ссылочный тип vs тип значения/память/бокс, в этом случае ответ "нет".

Наследование:

В С# выполняется следующее:

• Все типы значений, включая перечисления и типы с нулевым значением, выводятся из System.Object.
• Все типы классов, массивов и делегатов выводятся из System.Object.
• Типы интерфейсов не выводятся из System.Object. Все они конвертируются в System.Object, но интерфейсы выводятся только из других типов интерфейсов, а System.Object не является типом интерфейса.
• Никакие типы указателей не выводятся из System.Object, и ни один из них не может напрямую конвертироваться в System.Object.
• Типы параметров типа "Открытый" также не выводятся из System.Object. Типы типов параметров не производятся ничем; аргументы типа ограничены производными от эффективного базового класса, но сами они не являются "производными" от чего-либо.

Из запись MSDN для System.Object:

Поддерживает все классы в .NET. Иерархия классов Framework и обеспечивает низкоуровневые услуги для производных классов. Это конечный базовый класс всех классы в .NET Framework; это корень иерархии типов.

Языки обычно не требуют класс, чтобы объявить наследование из Объект, потому что наследование неявный.

Поскольку все классы в .NET Структура основана на объекте, каждый метод, определенный в объекте класс доступен во всех объектах в система. Производные классы могут и делают переопределите некоторые из этих методов.

Поэтому не каждый тип в С# получается из System.Object. И даже для тех типов, которые есть, вам все равно нужно отметить разницу между ссылочными типами и значения типов, поскольку они обрабатываются очень по-разному.

Бокс:

В то время как типы значений наследуют от System.Object, они обрабатываются по-разному в памяти из ссылочных типов, а семантика того, как они передаются через методы в вашем коде, также различны. Действительно, тип значения не рассматривается как объект (ссылочный тип), пока вы явно не поручите вашему приложению сделать это, поместив его в качестве ссылочного типа. См. дополнительную информацию о боксе в С# здесь.

Ответ 2

Немного поздно для вечеринки, но я наткнулся на это в результатах поиска по SO и понял, что приведенная ниже ссылка поможет будущим поколениям:

Эрик Липперт обсуждает это очень тщательно с гораздо лучшим (квалифицированным) утверждением:

Способ исправить этот миф состоит в том, чтобы просто заменить "выводится из" на "is convertible to" и игнорировать типы указателей: каждый тип не указателя в С# конвертируется в объект.

Суть его, если вы ненавидите читать хорошо иллюстрированные объяснения от людей, которые пишут языки программирования, заключается в том, что (указатели в сторону), такие вещи, как интерфейс или общие объявления типов параметров ( "T" ), не являются объектами, а являются гарантированно поддаются лечению как объекты во время выполнения, потому что они имеют определенный экземпляр, который будет объектом. Другие типы (Type, Enum, Delegate, classes и т.д.) - все объекты. Включая типы значений, которые могут быть помещены в бокс, поскольку обсуждались другие ответы.

Ответ 3

У некоторых людей есть странное представление о том, что такое "объект" в объектно-ориентированном программировании. Чтобы что-то было объектом, оно не должно быть ссылочным типом или, в более общем плане, следовать какой-либо формальной реализации.

Все это означает, что вы можете работать на нем как первоклассный гражданин в объектно-ориентированном мире. Поскольку вы можете сделать это по значениям на С# (благодаря автобоксингу), все действительно является объектом. В некоторой степени это справедливо для функций (но, возможно, не для классов).

Является ли это актуальным на практике, это другой вопрос, но это общая проблема с ООП, которую я замечаю еще раз. Никто не объясняет определение ООП (да, большинство людей согласны с тем, что оно имеет какое-то отношение к полиморфизму, наследованию и инкапсуляции, некоторые бросают "абстракцию" для хорошей меры).

С точки зрения использования, каждое значение в С# обрабатывается как объект. Тем не менее, мне нравится принятый в настоящее время ответ. Он предлагает как технически важные аспекты.

Обратите внимание, что в других контекстах, например, С++, другие аспекты подчеркнуты, поскольку С++ не обязательно объектно-ориентирован и, кроме того, гораздо более ориентирован на аспекты низкого уровня. Таким образом, различие между объектами, POD и встроенными примитивами иногда имеет смысл (затем снова, иногда нет).

Ответ 4

Все они рассматриваются как объекты, но они не все объекты. Путаница приходит с Autoboxing.

См. это для получения дополнительной информации: http://en.wikipedia.org/wiki/Object_type

Абстракция смущает людей.

Ответ 5

Я думал, что типы значений НЕ являются объектами. Они хранятся по-разному в памяти с помощью CLR - значения типов хранятся в стеке, а объекты хранятся в куче. Вы можете использовать типы значений для ссылочного типа, чтобы заставить их действовать как объект, но CLR снимает значение с стека, обертывает его в объект и сохраняет его в куче. Это то, что происходит, когда вы "вставляете" переменную.

Ответ 6

Вы путаете объект со значением или ссылкой. В принципе, все это объект. Int - это объект, но он также является типом значения. Экземпляр класса является объектом, но он также является ссылочным типом.

Методы не являются объектами и не являются свойствами. Просто работайте над объектами. И да, почти все наследуется от класса объекта.

Ответ 7

В С# (и вообще в ООП) мы имеем типы (класс - reference, struct - value и т.д.). Это определения. И "объект" - это конкретный экземпляр данного типа.

Итак, если мы читаем вопрос буквально, да, все будет объектом при создании экземпляра.

Смятение, скорее всего, начинается с плохого выбора имени самого базового класса для всего. В .NET это класс Object.

Ответ 8

Основываясь на всех прочитанных мной книгах, все в С# является объектом.

Некоторые из них относятся к типу Value. Объект типа значения наследует класс ValueType. У них другое поведение, но по сути... объекты.

Вот почему вы можете хранить Int32 в переменной объекта, а также все, что вы когда-либо могли создать в .NET.

Подробнее... посмотрите на следующее: http://msdn.microsoft.com/en-us/library/s1ax56ch(VS.71).aspx

Все типы значений выводятся неявно из класса Object.

Ответ 9

От: Типы значений (ссылка на С#) - MSDN 3.5

Все типы значений выводятся неявно из System.ValueType.

От: Класс типа значений - MSDN 3.5

ValueType переопределяет виртуальную методы из объекта с более соответствующие реализации для ценности типы.

От: Enum Class - MSDN 3.5

Этот класс наследует от ValueType

Иерархия наследования следующая:

• System.Object
  • System.ValueType
    • System.Enum

Заключение: Все есть объект

Ответ 10

Зависит от того, что вы подразумеваете под "всем" и "является объектом". Если вы определяете эти два термина, ответ прост: -)

Например, на некоторых языках if-block - это объект, который может передаваться как значение, назначаемое переменной и т.д. Это не относится к С#, поэтому явно не все является объектом в С#.

Ответ 11

В то время как все, кажется, сосредотачиваются на дебатах типов значений против обсуждения типов ссылок, мы забываем один тип в С#, который не является ни ссылкой, ни значением, он не является результатом объекта и не может быть передан объекту: указатели.

В отличие от значений и ссылочных типов, указатели не могут быть переданы объекту.

В соответствии с документацией MSDN для типов указателей С#,

Типы указателей не наследуются от объекта и нет конверсий между типами указателей и объектом. Кроме того, бокс и распаковка не указатели поддержки. Однако вы можете конвертировать между разными указателями типов и между типами указателей и интегральные типы.

Ответ 12

Типы значений не являются объектами, они подчиняются разной семантике копирования, различной передающей семантике и должны быть обернуты в класс (объект), чтобы считаться таковыми.

Изменить: Я думаю, что аргумент несколько расплывчатый, так как вы должны определить, что вы подразумеваете под "объектом". Является ли объект только тем, что наследуется от Object, или это то, что подчиняется семантике использования объекта? Или мы говорим о самом общем определении объекта, где это все, что может содержать данные и операции над этими данными?

Ответ 13

Число 2 не является объектом.

Ответ 14

С# был обозначен как система унифицированного типа. Это означает, что все можно рассматривать как объект. Однако под этим существуют два разных типа: типы значений и ссылочные типы. Типы значений можно рассматривать как объект через механизм бокса. Это означает, что создается объект, представляющий значение соответствующего типа значения.

Ответ 15

Учитывая, что вопрос относится к объекту в смысле ООП, ответы таковы:

С точки зрения технической ответ: Нет

С точки зрения догматической ответ: Да

Пояснение:

Типы технических значений (примитивы или структуры) не являются объектами, если только в форме "в штучной упаковке", а потому, что .Net делает бесшовные преобразования типов значений в их экземпляр объекта через действие бокса/распаковки (создание экземпляра класса, который выполняется значение и выводится из Object), что означает, что типы значений могут рассматриваться как оба объекта и простые значения.

Таким образом, типы значений являются двойственными по своей природе, они ведут себя как значения и как объекты. Значения в .Net являются объектами, когда они должны быть, и они не являются объектами в остальных случаях.

Правильный ответ, который учитывает технический аспект: "Все в .Net , как будто это объект".

Догматический ответ: "Все есть объект".

Ответ 16

Это обсуждение двух миров: языка и памяти.

Для меня язык подобен слою абстракции, а термин object принадлежит этому уровню абстракции. Я не вижу смысла говорить об объектах в терминах организации memeory, и если вы используете термин "объект", когда говорите о памяти, вы фактически заимствуете этот термин из другого уровня абстракции. Таким образом, вы не должны забывать, откуда оно взялось.

Если мы говорим о С#, я не понимаю, почему кто-то использовал бы организацию памяти в качестве аргумента. Конечно, если бы я ответил на этот вопрос кому-то, я бы сказал: "Да, на С# все есть объект, но вы также должны знать, что под капотом он может работать по-разному в зависимости от..."

Это может начать интересный аргумент, но может также говорить с некоторыми: в аналогичном обсуждении можно было бы сказать, что на самом деле нет объектно-ориентированного программирования, там только процедурное программирование. ЦП понимает объекты? Еще лучше, на самом деле нет программного обеспечения, там только разные аппаратные состояния:)

Моя точка зрения состоит в том, что некоторые термины не переводятся на другие уровни абстракции, и вы должны придерживаться обсуждения там, где он принадлежит (что в данном случае является языком, а не памятью).

Даже автор этого вопроса заявил: "Обратите внимание, что этот вопрос не связан с С# не обязательно .NET и как он обрабатывает данные под капотом (очевидно, все это 1 и 0.)"

Ответ 17

Адресация семантики. Зачем перегружать слово "объект" так, чтобы оно означало "ссылочный тип", когда у нас уже есть совершенно хороший, недвусмысленный термин для этого → "Тип ссылки", а когда, перегружая слово "Объект" таким образом мы создаем путаницу, которую демонстрирует этот поток... т.е. Несоответствие между тем, что все типы (включая типы значений) наследуют реализацию, определенную в типе "System.Object". Понятно, что это в лучшем случае не нужно, а в худшем случае крайне запутанно. Даже тот факт, что документация MS иногда путается по этому вопросу, не является оправданием для распространения путаницы.

Намного проще и понятнее просто определить и использовать термин "объект" для обозначения экземпляра ЛЮБОГО типа, значения или ссылки и фразы "Тип ссылки" для описания типов, в которых используются переменные указателя, и их состояние, сохраненное в куче...