>>интерфейсы

PD>Ну это как сказать. Поинтересуйся, как в Delphi c COM работают.

Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

Здравствуйте, Mamut, Вы писали:

PD>>Ну это как сказать. Поинтересуйся, как в Delphi c COM работают.

M>Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

Он в очередной раз потерял контекст, речь была про его любиый Turbo Pascal.

В ём не было интерфейсов ибо это досовская дрянь максимум на 16 бит и толко в реальном режиме процессора.

Здравствуйте, Mamut, Вы писали:

M> >>интерфейсы

M> PD>Ну это как сказать. Поинтересуйся, как в Delphi c COM работают.

M> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

Ты еще не устал эту глупость повторять?

Здравствуйте, hattab, Вы писали:

M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

H>Ты еще не устал эту глупость повторять?

А чем отличается COM от не-COM интерфейса ?

В правильном компилере, правильно, практически ничем.

Но ты, по Дельфям специалист, что поведаешь нам, в Дельфях ошибка или Дельфи плохо знаешь ты ?

Здравствуйте, Ikemefula, Вы писали:

I> M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

I> H>Ты еще не устал эту глупость повторять?

I> А чем отличается COM от не-COM интерфейса ?

I> В правильном компилере, правильно, практически ничем.

Много чем может отличаться. Я тебе больше скажу, понятие интерфейса вообще мало соотносится с конкректным компилятором.

I> Но ты, по Дельфям специалист, что поведаешь нам, в Дельфях ошибка или Дельфи плохо знаешь ты ?

У дельфей все в порядке, не беспокойся.

Здравствуйте, hattab, Вы писали:

H>Много чем может отличаться. Я тебе больше скажу, понятие интерфейса вообще мало соотносится с конкректным компилятором.

Потому и разницы быть не должно. А если она есть — компилер кривой.

I>> Но ты, по Дельфям специалист, что поведаешь нам, в Дельфях ошибка или Дельфи плохо знаешь ты ?
H>У дельфей все в порядке, не беспокойся.

Намёк понял я

Здравствуйте, Ikemefula, Вы писали:

I> H>Много чем может отличаться. Я тебе больше скажу, понятие интерфейса вообще мало соотносится с конкректным компилятором.

I> Потому и разницы быть не должно. А если она есть — компилер кривой.

Еще раз выделенное прочитай.

I> I>> Но ты, по Дельфям специалист, что поведаешь нам, в Дельфях ошибка или Дельфи плохо знаешь ты ?

I> H>У дельфей все в порядке, не беспокойся.

I> Намёк понял я

У меня тоже, спасибо.

Здравствуйте, hattab, Вы писали:

I>> H>Много чем может отличаться. Я тебе больше скажу, понятие интерфейса вообще мало соотносится с конкректным компилятором.

I>> Потому и разницы быть не должно. А если она есть — компилер кривой.

H>Еще раз выделенное прочитай.

Ты сам это прочитай.

M>> >>интерфейсы

M>> PD>Ну это как сказать. Поинтересуйся, как в Delphi c COM работают.

M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

H>Ты еще не устал эту глупость повторять?

Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

Здравствуйте, Mamut, Вы писали:

M> M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

M> H>Ты еще не устал эту глупость повторять?

M> Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

А при чем тут IUnknown? Да, в дельфях все интерфейсы наследуются от IUnknown (если быть точным — от IInterface, что суть тоже самое). Это нужно для совместимости с COM. При этом, далеко не каждый интерфейс будет являться COM-интерфейсом.

M>> M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

M>> H>Ты еще не устал эту глупость повторять?

M>> Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

H>А при чем тут IUnknown? Да, в дельфях все интерфейсы наследуются от IUnknown (если быть точным — от IInterface, что суть тоже самое). Это нужно для совместимости с COM. При этом, далеко не каждый интерфейс будет являться COM-интерфейсом.

Выделенное противоречит друг другу.

Вопрос: можно ли в дельфях сделать интерфейс, не наследующися от IUnknown? Зачем мне обязательная зависимость/совместимость с COM'ом?

пример:

interface Bicycle {

       void changeCadence(int newValue);   // wheel revolutions per minute

       void changeGear(int newValue);

       void speedUp(int increment);

       void applyBrakes(int decrement);
}

class ACMEBicycle implements Bicycle {

   // remainder of this class implemented as before

}

Вот нахрена мне тут IUknown? А вот он мне даром не нужен. Но нет, в Delphi я буду обязан реализовать все методы IUnknown'а или он автоматом будет реализован Delphi. Нахрена?

Здравствуйте, hattab, Вы писали:

M>> Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

H>А при чем тут IUnknown? Да, в дельфях все интерфейсы наследуются от IUnknown (если быть точным — от IInterface, что суть тоже самое). Это нужно для совместимости с COM. При этом, далеко не каждый интерфейс будет являться COM-интерфейсом.

"Но ты, по Дельфи специалист, что поведаешь нам, разница в чём или Дельфи плохо знаешь ты ?" @

Здравствуйте, Ikemefula, Вы писали:

I> M>> Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

I> H>А при чем тут IUnknown? Да, в дельфях все интерфейсы наследуются от IUnknown (если быть точным — от IInterface, что суть тоже самое). Это нужно для совместимости с COM. При этом, далеко не каждый интерфейс будет являться COM-интерфейсом.

I> "Но ты, по Дельфи специалист, что поведаешь нам, разница в чём или Дельфи плохо знаешь ты ?" @

Чтоб сильно тебя не раскармливать... В дельфях можно объявить интерфейс без GUID'а.

Здравствуйте, Mamut, Вы писали:

M> M>> M>> Это грязный хак для работы с COM-ом. Не знаю, как сейчас, но в Delphi не было не-COM интерфейсов.

M> M>> H>Ты еще не устал эту глупость повторять?

M> M>> Покажи мне не-COM интерфейс в дельфи. Такой, который бы не требовал реализации IUnknown и т.п.

M> H>А при чем тут IUnknown? Да, в дельфях все интерфейсы наследуются от IUnknown (если быть точным — от IInterface, что суть тоже самое). Это нужно для совместимости с COM. При этом, далеко не каждый интерфейс будет являться COM-интерфейсом.

M> Выделенное противоречит друг другу.

Нет там никакого противоречия.

M> Вопрос: можно ли в дельфях сделать интерфейс, не наследующися от IUnknown?

Интерфейс в дельфях всегда наследуется от IInterface.

M> Зачем мне обязательная зависимость/совместимость с COM'ом?

Наличие IUnknown не делает интерфейс COM-совместимым. Сурпрайз?

M> пример:

M>

M> interface Bicycle {

M>        void changeCadence(int newValue);   // wheel revolutions per minute

M>        void changeGear(int newValue);

M>        void speedUp(int increment);

M>        void applyBrakes(int decrement);
M> }

M> class ACMEBicycle implements Bicycle {

M>    // remainder of this class implemented as before

M> }
M>

M> Вот нахрена мне тут IUknown? А вот он мне даром не нужен. Но нет, в Delphi я буду обязан реализовать все методы IUnknown'а или он автоматом будет реализован Delphi. Нахрена?

IUnknown обязателен в дельфях для гармоничного встраивания в инфраструктуру COM и вместе с тем это элегантное решение проблемы управляемого времени жизни. Можно ли было, для поддержки интерфейсов, обойтись без IUnknown вообще? Разумеется. Но в таком случае пришлось бы разделять понятия интерфейса в рамках языка и интерфейса для COM (плюс обеспечивать механизм управления временем жизни). Какой в этом смысл? Никакого. Лишние сущности. Ситуация с интерфейсами в дельфях совершенно нормальна. Можно применять COM-совместимые интерфейсы, а можно и такие которые в рамках COM использованы быть не могут (но при этом, двух разных понятий об интерфейсах не существует). Ты не обязан самостоятельно реализовывать IUnknown, достаточно унаследоваться от класса его реализующего.

Здравствуйте, hattab, Вы писали:

I>> "Но ты, по Дельфи специалист, что поведаешь нам, разница в чём или Дельфи плохо знаешь ты ?" @

H>Чтоб сильно тебя не раскармливать... В дельфях можно объявить интерфейс без GUID'а.

Гуид к интерфейсу не имеет никакого отношения.

M>> Вопрос: можно ли в дельфях сделать интерфейс, не наследующися от IUnknown?
H>Интерфейс в дельфях всегда наследуется от IInterface.

Зачем?

M>> Зачем мне обязательная зависимость/совместимость с COM'ом?
H>Наличие IUnknown не делает интерфейс COM-совместимым. Сурпрайз?

Зачем тогда мне QueryInterface, AddRef и Release? Чтобы просто так были?

M>> пример:

M>>

M>> interface Bicycle {

M>>        void changeCadence(int newValue);   // wheel revolutions per minute

M>>        void changeGear(int newValue);

M>>        void speedUp(int increment);

M>>        void applyBrakes(int decrement);
M>> }

M>> class ACMEBicycle implements Bicycle {

M>>    // remainder of this class implemented as before

M>> }
M>>

M>> Вот нахрена мне тут IUknown? А вот он мне даром не нужен. Но нет, в Delphi я буду обязан реализовать все методы IUnknown'а или он автоматом будет реализован Delphi. Нахрена?

H>IUnknown обязателен в дельфях для гармоничного встраивания в инфраструктуру COM и вместе с тем это элегантное решение проблемы управляемого времени жизни.

Ничего нем элегантного нет. TObject не управляет временем жизни, и как-то без этого обходятся, а для интерфейсов ВНЕЗАПНО понадобилось управление?

H>Можно ли было, для поддержки интерфейсов, обойтись без IUnknown вообще? Разумеется. Но в таком случае пришлось бы разделять понятия интерфейса в рамках языка и интерфейса для COM (плюс обеспечивать механизм управления временем жизни). Какой в этом смысл? Никакого. Лишние сущности.

Лишние сущности — это насаждение QueryInterface, AddRef и Release повсюду, где они и не нужны. Нужен COM-интерфейс? Отнаследуйся себе от IInterface/IUnknown — и вперед.

H>Ситуация с интерфейсами в дельфях совершенно нормальна. Можно применять COM-совместимые интерфейсы, а можно и такие которые в рамках COM использованы быть не могут (но при этом, двух разных понятий об интерфейсах не существует). Ты не обязан самостоятельно реализовывать IUnknown, достаточно унаследоваться от класса его реализующего.

Ты не поверишь. Это возможно в любом языке с ООП. Только в нормальных языках никто не запихивает ненужные методы тебе в глотку, как это делает delphi.

В итоге что надо делать для каждого объекта? Правильно:

TMyClass = class(TInterfacedObject, IMyInterface)

потому что там, где мне даром не нужны три ненужных мне метода, я просто обязан их реализовать.

Здравствуйте, Ikemefula, Вы писали:

I> I>> "Но ты, по Дельфи специалист, что поведаешь нам, разница в чём или Дельфи плохо знаешь ты ?" @

I> H>Чтоб сильно тебя не раскармливать... В дельфях можно объявить интерфейс без GUID'а.

I> Гуид к интерфейсу не имеет никакого отношения.

К COM интерфейсу еще как имеет.

Здравствуйте, Mamut, Вы писали:

M> M>> Вопрос: можно ли в дельфях сделать интерфейс, не наследующися от IUnknown?

M> H>Интерфейс в дельфях всегда наследуется от IInterface.

M> Зачем?

Совместимость с COM + управление временем жизни. Я ведь написал уже.

M> M>> Зачем мне обязательная зависимость/совместимость с COM'ом?

M> H>Наличие IUnknown не делает интерфейс COM-совместимым. Сурпрайз?

M> Зачем тогда мне QueryInterface, AddRef и Release? Чтобы просто так были?

Управление временем жизни. Единое поведение интерфейсных типов.

M> H>IUnknown обязателен в дельфях для гармоничного встраивания в инфраструктуру COM и вместе с тем это элегантное решение проблемы управляемого времени жизни.

M> Ничего нем элегантного нет. TObject не управляет временем жизни, и как-то без этого обходятся, а для интерфейсов ВНЕЗАПНО понадобилось управление?

Было бы лучше, если бы для COM-интерфейсов время жизни было управляемым, а для остальных нет? Зачем плодить сущности без надобности?

M> H>Можно ли было, для поддержки интерфейсов, обойтись без IUnknown вообще? Разумеется. Но в таком случае пришлось бы разделять понятия интерфейса в рамках языка и интерфейса для COM (плюс обеспечивать механизм управления временем жизни). Какой в этом смысл? Никакого. Лишние сущности.

M> Лишние сущности — это насаждение QueryInterface, AddRef и Release повсюду, где они и не нужны. Нужен COM-интерфейс? Отнаследуйся себе от IInterface/IUnknown — и вперед.

Нафиг нужно это разграничение (COM/не COM), когда для поддержки обоих видов требуется идентичная функциональность?

M> H>Ситуация с интерфейсами в дельфях совершенно нормальна. Можно применять COM-совместимые интерфейсы, а можно и такие которые в рамках COM использованы быть не могут (но при этом, двух разных понятий об интерфейсах не существует). Ты не обязан самостоятельно реализовывать IUnknown, достаточно унаследоваться от класса его реализующего.

M> Ты не поверишь. Это возможно в любом языке с ООП. Только в нормальных языках никто не запихивает ненужные методы тебе в глотку, как это делает delphi.

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

M> В итоге что надо делать для каждого объекта? Правильно:
M>

M> TMyClass = class(TInterfacedObject, IMyInterface)
M>

M> потому что там, где мне даром не нужны три ненужных мне метода, я просто обязан их реализовать.

А в чем принципиальный затык наследования от TInterfacedObject, вместо TObject, кроме маразматического эстетства?

M>> M>> Вопрос: можно ли в дельфях сделать интерфейс, не наследующися от IUnknown?
M>> H>Интерфейс в дельфях всегда наследуется от IInterface.
M>> Зачем?

H>Совместимость с COM + управление временем жизни. Я ведь написал уже.

Стоп. То у тебя интерфейсы совместимы с COM, то они не совместимы. Ты уже определись


M>> H>IUnknown обязателен в дельфях для гармоничного встраивания в инфраструктуру COM и вместе с тем это элегантное решение проблемы управляемого времени жизни.
M>> Ничего нем элегантного нет. TObject не управляет временем жизни, и как-то без этого обходятся, а для интерфейсов ВНЕЗАПНО понадобилось управление?

H>Было бы лучше, если бы для COM-интерфейсов время жизни было управляемым, а для остальных нет? Зачем плодить сущности без надобности?

Это не плождение сущностей без надобности. Интерфейс — это вообще, по сути, абстрактный класс, контракт на исполнение. IInterface обязует всю наследующую цепочку реализовывать определенный контракт. Который даром не сдался для не-COM сущностей. Который ларом не сдался для сущностей, которые не обязаны быть COM-совместимыми.

M>> H>Можно ли было, для поддержки интерфейсов, обойтись без IUnknown вообще? Разумеется. Но в таком случае пришлось бы разделять понятия интерфейса в рамках языка и интерфейса для COM (плюс обеспечивать механизм управления временем жизни). Какой в этом смысл? Никакого. Лишние сущности.

M>> Лишние сущности — это насаждение QueryInterface, AddRef и Release повсюду, где они и не нужны. Нужен COM-интерфейс? Отнаследуйся себе от IInterface/IUnknown — и вперед.

H>Нафиг нужно это разграничение (COM/не COM), когда для поддержки обоих видов требуется идентичная функциональность?

С какоко перепугу она вдруг требуется? ТО, что так сделали в Delphi — ну так это проблемы Delphi, что они изначально все на COM завязали.

M>> H>Ситуация с интерфейсами в дельфях совершенно нормальна. Можно применять COM-совместимые интерфейсы, а можно и такие которые в рамках COM использованы быть не могут (но при этом, двух разных понятий об интерфейсах не существует). Ты не обязан самостоятельно реализовывать IUnknown, достаточно унаследоваться от класса его реализующего.

M>> Ты не поверишь. Это возможно в любом языке с ООП. Только в нормальных языках никто не запихивает ненужные методы тебе в глотку, как это делает delphi.

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


Абстрактные классы в С++ — это и есть интерфейсы. И в С++ есть бесшовная связка с COM. Не путай мух и котлет. Мухи отдельно, котлеты отдельно.

Нативный-ненативный значения не имеет. Интерфейсы вообще к COM'у никакого отношения не имеют.


M>> В итоге что надо делать для каждого объекта? Правильно:
M>>

M>> TMyClass = class(TInterfacedObject, IMyInterface)
M>>

M>> потому что там, где мне даром не нужны три ненужных мне метода, я просто обязан их реализовать.

H>А в чем принципиальный затык наследования от TInterfacedObject, вместо TObject, кроме маразматического эстетства?

В том, что никому даром не уперлись QueryInterface, AddRef и Release, кроме как в случае работы с COM'ом. И обязательная совместимость с COM'ом тоже даром не упала. Нужна совместимость с COM'ом — вперед, наследуйся от IINterface/TInterfacedObject и радуйся жизни, как это во всех нормальных языках делают.

Здравствуйте, Mamut, Вы писали:

M> H>Совместимость с COM + управление временем жизни. Я ведь написал уже.

M> Стоп. То у тебя интерфейсы совместимы с COM, то они не совместимы. Ты уже определись

Я что, непонятно написал? IUnknown нужен для совместимости с COM, но это не значит, что любой интерфейс будет совместим с COM.

M> M>> Ничего нем элегантного нет. TObject не управляет временем жизни, и как-то без этого обходятся, а для интерфейсов ВНЕЗАПНО понадобилось управление?

M> H>Было бы лучше, если бы для COM-интерфейсов время жизни было управляемым, а для остальных нет? Зачем плодить сущности без надобности?

M> Это не плождение сущностей без надобности. Интерфейс — это вообще, по сути, абстрактный класс, контракт на исполнение. IInterface обязует всю наследующую цепочку реализовывать определенный контракт. Который даром не сдался для не-COM сущностей. Который ларом не сдался для сущностей, которые не обязаны быть COM-совместимыми.

Ты какую-то формулировку берешь за догму, и говоришь, что в дельфях оно не так, а значит все плохо? Не смеши меня больше.

M> M>> H>Можно ли было, для поддержки интерфейсов, обойтись без IUnknown вообще? Разумеется. Но в таком случае пришлось бы разделять понятия интерфейса в рамках языка и интерфейса для COM (плюс обеспечивать механизм управления временем жизни). Какой в этом смысл? Никакого. Лишние сущности.

M> M>> Лишние сущности — это насаждение QueryInterface, AddRef и Release повсюду, где они и не нужны. Нужен COM-интерфейс? Отнаследуйся себе от IInterface/IUnknown — и вперед.

M> H>Нафиг нужно это разграничение (COM/не COM), когда для поддержки обоих видов требуется идентичная функциональность?

M> С какоко перепугу она вдруг требуется?

Для единообразия. Еще раз:

M> H>Было бы лучше, если бы для COM-интерфейсов время жизни было управляемым, а для остальных нет?

M> ТО, что так сделали в Delphi — ну так это проблемы Delphi, что они изначально все на COM завязали.

Интерфейсы там появились благодаря COM, это несомненно. И именно благодаря одному из ключевых моментов COM (QueryInterface) достигается офигительный профит при их использовании. Без аналогичного механизма поддержка интерфейсов не более чем пшик.

M> M>> Ты не поверишь. Это возможно в любом языке с ООП. Только в нормальных языках никто не запихивает ненужные методы тебе в глотку, как это делает delphi.

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

M> Абстрактные классы в С++ — это и есть интерфейсы. И в С++ есть бесшовная связка с COM. Не путай мух и котлет. Мухи отдельно, котлеты отдельно.

M> Нативный-ненативный значения не имеет. Интерфейсы вообще к COM'у никакого отношения не имеют.

Я в данном случае не о COM говорю. И нативность тут имеет самое непосредственное значение и вот почему. Если на управляемых платформах все обвешано метой и царит "полное взаимопонимание" между взаимодействующими сущностями т.к. работают они в однородной среде, то в нативе всего этого нет. Без того самого IUnknown (или его аналога) работа с интерфейсами в нативе была бы невозможна в принципе. Следует понимать, что дельфя это все же разработка нативных приложений и следовательно принимаемые решения основываются на данном факте. Т.ч. эти ваши сопли о нормальных языках тут не катят.

M> H>А в чем принципиальный затык наследования от TInterfacedObject, вместо TObject, кроме маразматического эстетства?

M> В том, что никому даром не уперлись QueryInterface, AddRef и Release, кроме как в случае работы с COM'ом. И обязательная совместимость с COM'ом тоже даром не упала. Нужна совместимость с COM'ом — вперед, наследуйся от IINterface/TInterfacedObject и радуйся жизни, как это во всех нормальных языках делают.

Еще раз: IUnknown это не работа с COM. Это базовый элемент COM, да, но не более.