Все находится в.NET объектом?
Для тех, кто не знает, как использовать PDO (исходя из функций В основном читайте mysql_), я сделал очень, очень простую PDO-обертку , которая представляет собой один файл. Он существует, чтобы показать, насколько легко выполнять все обычные приложения, которые необходимо выполнить. Работает с PostgreSQL, MySQL и SQLite.
Мне нужен один столбец
$count = DB::column('SELECT COUNT(*) FROM `user`);Мне нужны результаты массива (key => value) (т. е. для создания selectbox)
$pairs = DB::pairs('SELECT `id`, `username` FROM `user`);Мне нужен результат одной строки
$user = DB::row('SELECT * FROM `user` WHERE `id` = ?', array($user_id));Мне нужен массив результатов
$banned_users = DB::fetch('SELECT * FROM `user` WHERE `banned` = ?', array(TRUE));
17 ответов
Проблема здесь состоит в том, что это - действительно два вопроса - один вопрос о наследовании, в этом случае ответ, "почти все" и другой о ссылочном типе по сравнению с типом/памятью/упаковкой значения, которые случаются, ответ является "нет".
Наследование:
В C#, следующее верно:
- Все типы значения, включая перечисления и nullable типы, получены от
System.Object. - Весь класс, массив и типы делегата получены от
System.Object. - Интерфейсные типы не получены от
System.Object. Они - весь кабриолет кSystem.Object, но взаимодействует через интерфейс, только происходят из других интерфейсных типов, иSystem.Objectне интерфейсный тип. - Никакие типы указателей не происходят от
System.Object, и при этом любой из них не непосредственно конвертируем кSystem.Object. - "Открытые" типы параметра типа также не получены от
System.Object. Типы параметра типа ни из чего не получены; аргументы типа вынуждены быть полученными из эффективного базового класса, но они сами ни из чего не "получены".
От [1 110] запись MSDN для Системы. Объект :
Поддержки все классы в иерархии классов Платформы.NET и предоставляет услуги низкого уровня производным классам. Это - окончательный базовый класс всех классов в Платформе.NET; это - корень иерархии типа.
Языки обычно не требуют, чтобы класс объявил наследование от Объекта, потому что наследование неявно.
, поскольку все классы в Платформе.NET получены из Объекта, каждый метод, определенный в Классе объекта, доступен во всех объектах в системе. Производные классы могут и действительно переопределять некоторые из этих методов.
Так не каждый тип в C# получен от System.Object. И даже для тех типов, которые являются, все еще необходимо отметить различие между [1 111] ссылочные типы и типы значения , поскольку их рассматривают очень по-другому.
Упаковка:
, В то время как типы значения делают , наследовались от System.Object, их рассматривают по-другому в памяти от ссылочных типов и семантике того, как они передаются через методы в Вашем коде, отличаются также. Действительно, тип значения не рассматривают как Объект (ссылочный тип), пока Вы явно не даете своему приложению команду делать так путем упаковки его как ссылочного типа. См. [еще 1113] информация об окружении C# здесь .
Полагая, что вопрос относится для Возражения в смысле ООП, ответы:
От технический точка зрения ответ: Никакой
От догматичный точка зрения ответ: Да
Объяснение:
Технически типы значения (примитивы или структуры) не являются объектами, если в "помещенной в коробку" форме, но потому что.Net делает бесшовные преобразования типов значения к их Объектному дубликату посредством действия упаковки/распаковывания (создающий экземпляр класса, который содержит значение и получен из Объекта), который означает типы значения, может рассматриваться как оба объекта и простые значения.
, Таким образом, типы значения являются двойными по своей природе, они ведут себя как [1 112] значения и как [1 113] объекты . Значения в.Net являются Объектами, когда они должны быть, и они не объекты в остальной части случаев.
корректный ответ, который принимает технический аспект во внимание, "Все в.Net , как будто это было Объект".
догматический ответ, "Все - Объект".
C# имеет, был, упоминается как объединенная система типов. Это означает, что все может рассматриваться как объект. Однако под этим существует два различных типов: оцените типы и ссылочные типы. Типы значения могут быть просмотрены как объект с помощью механизма упаковки. Это означает, что объект создается, представляя значение рассматриваемого типа значения.
Типы значения не являются объектами, они повинуются различной семантике копирования, различной передающей семантике, и должны быть обернуты в класс (Объект) для обработки как таковые.
Редактирование: Я думаю, что аргумент несколько неопределенен, поскольку необходимо квалифицировать то, что Вы подразумеваете под 'объектом'. Объект - просто что-то, что наследовалось Объекту или является им что-то, что повинуется семантике использования Объекта? Или мы говорим самое общее определение объекта, где это - что-нибудь, что может содержать данные и операции на тех данных?
В то время как все, кажется, фокусируются на типах значения по сравнению с дебатами ссылочных типов, мы забываем один тип в C#, который не является ни ссылкой, ни значением, это не происходит из объекта, и это не может быть брошено для возражения: указатели.
В отличие от значений и ссылочных типов, указатели не могут быть брошены для возражения.
Согласно документация MSDN относительно типов указателей C# ,
Типы указателей не наследовались объекту, и никакие преобразования не существуют между типами указателей и объектом. Кроме того, упаковка и распаковывание не поддерживают указатели. Однако можно преобразовать между различными типами указателей и между типами указателей и целочисленными типами.
Зависит, что Вы подразумеваете под "всем", и "объект". При определении этих двух условий ответ является легким:-)
, Например, на некоторых языках , если-блок является объектом, который может быть роздан как значение, присвоенное переменной и так далее. Дело обстоит не так в C#, так ясно не все - объект в C#.
На основе всех книг, которые я прочитал, все в C# - объект.
Некоторые - ссылка другой, тип Значения. Текстовый объект значения наследовался классу ValueType . У них есть различное поведение, но по сути... возражает.
Это - причина, почему можно сохранить Int32 в переменной объекта, а также всем, что можно когда-либо создавать в.NET.
Для большего количества детали... смотрят на следующее: http://msdn.microsoft.com/en-us/library/s1ax56ch (По сравнению с 71) .aspx
Все типы значения получены неявно из Класса объекта.
В C# (и в ООП в целом) у нас есть типы (класс - ссылка, структура - значение, и т.д.). Это определения. И "объект" является конкретным экземпляром данного типа.
Так, если мы читаем вопрос буквально, да, все - объект, когда инстанцировано.
беспорядок по всей вероятности начинается с плохого выбора названия очень базового класса для всего. В .NET это - Класс объекта.
Вы путаете объект со значением или ссылкой. В основном все - объект. Интервал является объектом, но это - также тип значения. Экземпляр класса является объектом, но это - также ссылочный тип.
Методы не являются объектами, ни являются свойствами. Справедливые воздействуют на объекты. И да, в значительной степени все наследовалось классу объекта.
Я думал, что типы значения НЕ являются объектами. Они хранятся по-другому в памяти CLR - типы значения хранятся на стеке, и объекты хранятся на "куче". Можно бросить типы значения к ссылочному типу, чтобы заставить их действовать как объект, но CLR принимает значение прочь стека, обертывает его в объект и хранит его на "куче". Именно это происходит, когда Вы "упаковываете" переменную.
Они - весь , рассматривал как объекты, но они не все объекты. Беспорядок входит с Автоупаковкой.
Посмотрите это для получения дополнительной информации: http://en.wikipedia.org/wiki/Object_type
абстракция смущает людей, по-видимому.
У некоторых людей здесь есть странное понятие того, каков “object” в объектно-ориентированном программировании. Для чего-то, чтобы быть объектом это делает не , должны быть ссылочный тип или, в более общем плане, следовать за любой формальной реализацией.
Весь, чем средство состоит в том, что можно воздействовать на него как первоклассный гражданин в объектно-ориентированном мире. Начиная с Вас может делать это на значениях в C# (благодаря автоупаковке), все - действительно объект. Некоторым расширяются, это даже верно для функций (но возможно не для классов).
, Релевантно ли это на практике, другой вопрос, но это - общая проблема с ООП, которое я замечаю еще раз. Никто не ясен на определении ООП (да, большинство людей соглашается, что это имеет некоторое отношение к полиморфизму, наследованию и инкапсуляции, некоторые добавляют “abstraction” в придачу).
С точки зрения использования, каждое значение в C# обрабатывает как объект. Однако мне нравится в настоящее время принимаемый ответ. Это предлагает оба технически важных аспекта.
Уведомление, что в других контекстах, например, C++, другие аспекты подчеркнуты начиная с C++, не обязательно объектно-ориентировано и кроме того намного более фокусируется на аспектах низкого уровня. Поэтому различие между объектами, POD и встроенными примитивами иногда имеет смысл (с другой стороны, иногда не).
От: Типы Значения (Ссылка C#) - MSDN 3.5
Все типы значения получены неявно из Системы. ValueType.
От: Класс Типа Значения - MSDN 3.5
ValueType переопределяет виртуальные методы от Объекта с более соответствующими реализациями для типов значения.
Этот класс наследовался ValueType
, который Иерархия наследования следующие:
- Система. Объект
- Система. <Литий> система ValueType
- . Перечисление заключение
- Система. <Литий> система ValueType
: Все - объект
Обращаясь к семантике, зачем перегружать слово «объект», чтобы оно означало «ссылочный тип», когда у нас уже есть совершенно хороший, недвусмысленный термин для этого -> «Тип ссылки», и когда, перегрузив слово «Объект» таким образом, мы создаем путаницу, которую демонстрирует этот поток ... то есть несоответствие между фактом, что все типы, (включая типы значений), наследуют реализацию, определенную в типе «System.Object». ». Понятно, что в лучшем случае это не нужно, а в худшем случае крайне запутанно. Даже тот факт, что документация MS иногда смущает этот вопрос, не является оправданием для распространения путаницы.
Гораздо проще и яснее просто определить и использовать термин «объект» для обозначения ЛЮБОГО типа, значения или ссылки и фразы «
Это обсуждение двух миров: языка и памяти.
Для меня язык подобен слою абстракции, и термин объект относится к этому уровню абстракции. Я не вижу смысла говорить об объектах с точки зрения организации памяти, и если вы действительно используете термин «объект», когда говорите о памяти, вы фактически заимствуете этот термин из другого уровня абстракции. Таким образом, вы не должны забывать, откуда это взялось.
Если мы говорим о C #, я не понимаю, почему кто-то использовал организацию памяти в качестве аргумента. Конечно, если бы я ответил на этот вопрос кому-то, я бы сказал: «Да, в C # все является объектом, но вы также должны знать, что под капотом это может работать по-разному в зависимости от…».
Это может привести к интересный аргумент, но может также поговорить с некоторыми: в подобном обсуждении можно сказать, что на самом деле нет объектно-ориентированного программирования, есть только процедурное программирование. ЦП понимает объекты? Более того, на самом деле нет программного обеспечения, есть только разные аппаратные состояния:)
Моя точка зрения такова, что некоторые термины не переводятся на другие уровни абстракции, и вы должны придерживаться обсуждения, где оно принадлежит (что в данном случае язык, а не память).
Даже автор этого вопроса заявил: «Обратите внимание, что этот вопрос относится к C # не обязательно .NET и как он обрабатывает данные под капотом (очевидно, это все 1 и 0.)»
Немного поздно для вечеринки, но я наткнулся на это в результатах поиска на SO и решил, что ссылка ниже поможет будущим поколениям:
Эрик Липперт очень подробно обсуждает это с гораздо лучшим (квалифицированным) утверждением:
Способ исправить этот миф состоит в том, чтобы просто заменить «производный от» на «может быть преобразован в» и игнорировать типы указателей: каждый тип, не являющийся указателем, в C # может быть преобразован в объект.
Если вы ненавидите читать хорошо иллюстрированные объяснения людей, пишущих на языках программирования, то суть в том, что (за исключением указателей) такие вещи, как интерфейс или объявления типов общих параметров («T»), являются не объекты, но гарантированно обрабатываются как объекты во время выполнения, потому что у них есть определенный экземпляр, которым будет объект. Другие типы (Type, Enum, Делегат, классы и т. Д.) - все это объекты. Включая типы значений, которые могут быть помещены в объект, как обсуждали другие ответы.