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

H>>>>>>Порядок сам посчитаешь? Алгоритм идентичен. Проделываемая работа нет. Вот об этом я и говорил, что стремиться к идентичности весьма утопично.
H>>Читать и думать, думать и читать. В общем, я выделил для танкистов
J>Понимаешь, идентичен — это не значит что код должен выглядеть так-же, он должен делать ту-же самую работу. Реализачия строк в .net и Delphi совершенно разная внутри, так что соврал ты, когда говорил что "тоже против таких сравнений".

А-а-а, так ты за сравнение mov ax, bx... Удачи.

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

H>>>>Не тормозило. Добавили .NET -- стало тормозить. Ну?
J>>>По-твоему тормозит изза самого факта наличия .net-кода? Почему оно не может тормозить, скажем, изза новых фич или взаимодействия .net кода интероп нативным?
H>>Из-за новых фичь конечно может (вопрос лишь в том, много ли там новых фичь),
J>Видать достаточно, раз покупают.

Я вообще-то это сказал относительно контекста присутствия тормозов...

H>>и из-за интеропа тоже, но только интероп это не проблема нативного кода, а таки необходимость менеджед платформы в нативной среде.
J>Ну здравнствуйте, Капитан...

Так вот и нечего на интероп пенять, коли...

J>>>Причем ты сам утверждал что десктоп-приложений под дотнет практически нет.
H>>Да, их практически нет. Но у тех, что есть в области моей досягаемости, на моем десктопе тобишь, (два из трех, к слову сказать от МС )
J>А потом говорят что в МС .net сами не используют, а только кормят народу...

Paint.NET да WLW. Оба мелочь, оба сторонние, но под егидой МС Не ахти какой показатель (Студия под топик не подходит, посему увы и ах)

H>>Понимаешь какое дело, не всегда можно в точности повторить алгоритм, скажем, ввиду особенностей реализации некоторых примитивов. Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET.
J>Вот это и будет неидентичным сравнением.

С точки зрения алгоритма все идентично. Реализация да, не идентична, я о том и сказал.

H>>А если использовать идентичный алгоритм -- взять строки .NET? Просядет .NET на порядок? На два? Я не в курсе, как реализованы строки в .NET, может там чего-то страшное делается и ты снова скажешь, что это неидентичный алгоритм.
J>Как же ты сравниваешь их производительность, если не знаешь, как они реализованы?

Я и не сравниваю. Успокойся. Пример был дан дабы тебе показать бессмысленность слов об идентичности алгоритмов.

H>>Я это к чему говорю, доипаться можно и до столба, в результате придя к сравнению mov ax, bx.
J>Если и можно, то пока-что нафиг не надо, потому что все эти бенчи где дотнет проигрывает на порядок оказываются обычным говнокодом.

А-а-а, так ты все же не хочешь идентичного алгоритма, хочешь использовать приемы специфичные для платформы. Ну так и не нужно тут вещать о неидентичности.

H>>>>Это можно сделать с довольно объемными и сложными алгоритмами, но не в данном случае.
J>>>Да с любыми можно сделать, того-же quick-sort'а можно несколько вариантов сделать.
H>>Ты начинаешь придираться к словам.
J>

H>> Разумеется, даже гланды можно вырезать через жопу, но я думал мы все же реальные ситуации рассматриваем.
J>В реальности так и есть. Сначала пишется просто код (не оязательно плохой), потом, если оказывается что он тормозит и есть ресурсы на его оптимизацию — занимаются оптимизацией. Если бы все сразу оптимально писалось — у нас всё бы летало уже давно.

Демагогия.

H>>Ну так:
H>>

Bitmap Class
H>>Encapsulates a GDI+ bitmap, which consists of the pixel data for a graphics image and its attributes.

H>>Я конечно не в курсе, может Paint.NET, как-то по своему все обрабатывает, но что-то сильно в этом сомневаюсь.
J>Скорее всего именно по-своему.

Откуда, в таком случае, интероп при работе фильтров? Что, прогресс-бар так накручивает счетчик?

H>>>>Хочешь предметного разговора, показывай код Gaussian Blur из Paint.NET, который является проблемой (уж извини, не я сомневаюсь в кривости алгоритма)
J>>>Что-то я не смог найти исходники paint.net на их сайте . Похоже он больше не open source?
H>>Для версии 3.05 есть тут.
J>Там довольно большой для форума кусок кода, сюда приводить не буду, кому интересно посмотрят файл Effects/BlurEffect.cs. Только нужно сравнивать его с гимповским кодом, а кто это будет делать — .

Зачем сравнивать, ты по коду не можешь сказать какие там кривости? Или таки нет очевидных ляпов?

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

H>>>Понимаешь какое дело, не всегда можно в точности повторить алгоритм, скажем, ввиду особенностей реализации некоторых примитивов. Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET.
J>>Вот это и будет неидентичным сравнением.
H>С точки зрения алгоритма все идентично. Реализация да, не идентична, я о том и сказал.
Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().

H>>>Я это к чему говорю, доипаться можно и до столба, в результате придя к сравнению mov ax, bx.
J>>Если и можно, то пока-что нафиг не надо, потому что все эти бенчи где дотнет проигрывает на порядок оказываются обычным говнокодом.
H>А-а-а, так ты все же не хочешь идентичного алгоритма, хочешь использовать приемы специфичные для платформы. Ну так и не нужно тут вещать о неидентичности.
Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.

J>>В реальности так и есть. Сначала пишется просто код (не оязательно плохой), потом, если оказывается что он тормозит и есть ресурсы на его оптимизацию — занимаются оптимизацией. Если бы все сразу оптимально писалось — у нас всё бы летало уже давно.
H>Демагогия.


H>>>Ну так:
H>>>

Bitmap Class
H>>>Encapsulates a GDI+ bitmap, which consists of the pixel data for a graphics image and its attributes.

H>>>Я конечно не в курсе, может Paint.NET, как-то по своему все обрабатывает, но что-то сильно в этом сомневаюсь.
J>>Скорее всего именно по-своему.
H>Откуда, в таком случае, интероп при работе фильтров? Что, прогресс-бар так накручивает счетчик?
Незнаю, я не вникал в проблему.

H>Зачем сравнивать,
Как зачем? Может в гимпе применяется какой-то более совершенный алгоритм?

H>ты по коду не можешь сказать какие там кривости? Или таки нет очевидных ляпов?
Ну например безопасный доступ к массивам пикселей может всё сильно замедлять...

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

H>>>>Понимаешь какое дело, не всегда можно в точности повторить алгоритм, скажем, ввиду особенностей реализации некоторых примитивов. Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET.
J>>>Вот это и будет неидентичным сравнением.
H>>С точки зрения алгоритма все идентично. Реализация да, не идентична, я о том и сказал.
J>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().

Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.

H>>>>Я это к чему говорю, доипаться можно и до столба, в результате придя к сравнению mov ax, bx.
J>>>Если и можно, то пока-что нафиг не надо, потому что все эти бенчи где дотнет проигрывает на порядок оказываются обычным говнокодом.
H>>А-а-а, так ты все же не хочешь идентичного алгоритма, хочешь использовать приемы специфичные для платформы. Ну так и не нужно тут вещать о неидентичности.
J>Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.

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

H>>Зачем сравнивать,
J>Как зачем? Может в гимпе применяется какой-то более совершенный алгоритм?

В GIMP'е вообще два алгоритма. Скорость одного не зависит от радиуса (IIR), а скорость второго зависит (RLE). Ранее, в описаниях алгоритма Gaussian Blur я тоже встречал упоминание о двух вариантах. Т.е. есть смысл предполагать, что ничего особенно нового там не будет... Сравнение я делал на зависимом алгоритме.

H>>ты по коду не можешь сказать какие там кривости? Или таки нет очевидных ляпов?
J>Ну например безопасный доступ к массивам пикселей может всё сильно замедлять...

Это ведь особенность платформы?

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

J>>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().
H>Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.
А разве строки это базовые единицы? Что там считается строками в C++?

J>>Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.
H>Тогда алгоритм будет далеко не идентичен. Начиная с того самого момента, что даже механизмы распределения памяти разные.
Почему же не идентичен? Это реализация будет разная.

J>>Ну например безопасный доступ к массивам пикселей может всё сильно замедлять...
H>Это ведь особенность платформы?
Наверное да.

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

J>>>Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.
H>>Тогда алгоритм будет далеко не идентичен. Начиная с того самого момента, что даже механизмы распределения памяти разные.
J>Почему же не идентичен? Это реализация будет разная.
Тут ты конечно прав, на более низком уровне алгоритм конечно будет отличаться, так что тут длжна быть какая-то граница, где должна быть идентичность...

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

H>>>>Понимаешь какое дело, не всегда можно в точности повторить алгоритм, скажем, ввиду особенностей реализации некоторых примитивов. Взять хотя бы последнюю синтетику со сравнением строк. Взять конкатенацию. Обычные строки Delphi идут наровне со специализированным классом StringBuilder в .NET.
J>>>Вот это и будет неидентичным сравнением.
H>>С точки зрения алгоритма все идентично. Реализация да, не идентична, я о том и сказал.
J>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().

Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.

H>>>>Я это к чему говорю, доипаться можно и до столба, в результате придя к сравнению mov ax, bx.
J>>>Если и можно, то пока-что нафиг не надо, потому что все эти бенчи где дотнет проигрывает на порядок оказываются обычным говнокодом.
H>>А-а-а, так ты все же не хочешь идентичного алгоритма, хочешь использовать приемы специфичные для платформы. Ну так и не нужно тут вещать о неидентичности.
J>Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.

Тогда алгоритм будет далеко не идентичен. Начиная с того самого момента, что даже механизмы распределения памяти разные. Я уж не говорю об ассемблерных вставках и использовании расширенного набора инструкций. А чего, нативная платформа это позволяет делать не выходя за рамки

H>>Зачем сравнивать,
J>Как зачем? Может в гимпе применяется какой-то более совершенный алгоритм?

В GIMP'е вообще два алгоритма. Скорость одного не зависит от радиуса (IIR), а скорость второго зависит (RLE). Ранее, в описаниях алгоритма Gaussian Blur я тоже встречал упоминание о двух вариантах. Т.е. есть смысл предполагать, что ничего особенно нового там не будет, хотя... Сравнение я делал на зависимом алгоритме.

H>>ты по коду не можешь сказать какие там кривости? Или таки нет очевидных ляпов?
J>Ну например безопасный доступ к массивам пикселей может всё сильно замедлять...

Это ведь особенность платформы?

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

J>>>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().
H>>Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.
J>А разве строки это базовые единицы? Что там считается строками в C++?

В Delphi базовые, хотя и там строковый тип не один.

J>>>Ну например безопасный доступ к массивам пикселей может всё сильно замедлять...
H>>Это ведь особенность платформы?
J>Наверное да.

То-то и оно. Так что ни о какой идентичности тут речи быть не может.

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

J>>>>Дык я вроде приемы специфичные для платформы и не запрещал... Но тогда использовать их нужно по-максимуму в обоих случаях, а не только для своей любимой платформы.
H>>>Тогда алгоритм будет далеко не идентичен. Начиная с того самого момента, что даже механизмы распределения памяти разные.
J>>Почему же не идентичен? Это реализация будет разная.
J>Тут ты конечно прав, на более низком уровне алгоритм конечно будет отличаться, так что тут длжна быть какая-то граница, где должна быть идентичность...

Ну, либо базовые единицы, либо я не знаю Натив запросто может заюзать ассемблерные вставки с SSEx, будет ли это идентичностью? В общем, утопия это Другое дело, если позволять некоторый уровень девиаций от генеральной линии, но опять о допустимости не договориться будет.

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

J>>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().

H>Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.

Зашибись. Ниче что ни один здравомыслящий программист для аккумулирования строки не станет юзать string, а использует предназначенный для этого инструмент — StringBuilder?

А то давай напишем что-то вроде

for(int i=0; i<n; i++) { MyObj obj = new MyObj(); }

и "идентичный алгоритм" на Delphi

for i:=1 to n do obj := MyObj.Create;

на пару сотен миллионов итераций и сравним использование памяти ;]

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

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

H>>>>>>>Порядок сам посчитаешь? Алгоритм идентичен. Проделываемая работа нет. Вот об этом я и говорил, что стремиться к идентичности весьма утопично.
H>>>Читать и думать, думать и читать. В общем, я выделил для танкистов
J>>Понимаешь, идентичен — это не значит что код должен выглядеть так-же, он должен делать ту-же самую работу. Реализачия строк в .net и Delphi совершенно разная внутри, так что соврал ты, когда говорил что "тоже против таких сравнений".

H>А-а-а, так ты за сравнение mov ax, bx... Удачи.

Тебе намекают на то, что идентичностью в твоем примере нет. В Delphi ты используешь сущность реализующую мутабельную строку. В шарпе — имутабельную. В шарпе для мутабельной строки есть другая сущность. Так что идентичностью в твоем примере и не пахнет. И если 2 разные сущности обозначаются одним и тем же именем — класс String в твоем случае (это на что тебе jenyavb намекал выделяя слово выглядеть) это еще не значи, что они одинаковы.

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

J>>>Нет, алгоритмы тоже разные. Причем алгоритмы эти внутри реализации строк. В дотнете исходные строки при конкатенации будут каждый раз копироваться, а в дельфи всё будет просто добавляться к исходной строке. Где же тут идентичность алгоритма? Используй тогда уж StringBuilder, а по завершению построения вызывай у него ToString().

H>>Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.

kuj>Зашибись. Ниче что ни один здравомыслящий программист для аккумулирования строки не станет юзать string, а использует предназначенный для этого инструмент — StringBuilder?

Ты хоть читай немного, перед тем, как в эфир выходишь

kuj>А то давай напишем что-то вроде

kuj>for(int i=0; i<n; i++) { MyObj obj = new MyObj(); }

kuj>и "идентичный алгоритм" на Delphi

kuj>for i:=1 to n do obj := MyObj.Create;

kuj>на пару сотен миллионов итераций и сравним использование памяти ;]

Алгоритм идентичен, только ты мусор вынести забыл.

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

H>>А-а-а, так ты за сравнение mov ax, bx... Удачи.

Y>Тебе намекают на то, что идентичностью в твоем примере нет. В Delphi ты используешь сущность реализующую мутабельную строку. В шарпе — имутабельную. В шарпе для мутабельной строки есть другая сущность. Так что идентичностью в твоем примере и не пахнет. И если 2 разные сущности обозначаются одним и тем же именем — класс String в твоем случае (это на что тебе jenyavb намекал выделяя слово выглядеть) это еще не значи, что они одинаковы.

Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен -- конкатенация выполнена естественным способом), неидентична выполняемая работа всилу различной реализации базовых типов (но где, блин, граница, а? mov ax, bx? Чудно!). Ну сколько можно???

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

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

H>>>А-а-а, так ты за сравнение mov ax, bx... Удачи.

Y>>Тебе намекают на то, что идентичностью в твоем примере нет. В Delphi ты используешь сущность реализующую мутабельную строку. В шарпе — имутабельную. В шарпе для мутабельной строки есть другая сущность. Так что идентичностью в твоем примере и не пахнет. И если 2 разные сущности обозначаются одним и тем же именем — класс String в твоем случае (это на что тебе jenyavb намекал выделяя слово выглядеть) это еще не значи, что они одинаковы.

H>Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен -- конкатенация выполнена естественным способом), неидентична выполняемая работа всилу различной реализации базовых типов (но где, блин, граница, а? mov ax, bx? Чудно!). Ну сколько можно???

Говоря про естественность ты имеешь в виду выглядит одинаково? Твоя реализация алгоритма выглядит неестественно для C#, если что.
Еще раз: задача была привести аналогичные алгоритмы, а не алгоритмы, кажущиеся естественными тебе или алгоритмы использующие базовые типы (StringBuilder находиться в Base Class Library, если что).
А теперь давай по простому, может тогда поймешь:
Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

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

H>>>Вот это и есть сравнение mov ax, bx. Только смысл? Правильнее сравнивать базовые единицы платформ: строки со строками, объекты с объектами, массивы с массивами. А вот уж, как это реализовано, остается на совести платформы.

kuj>>Зашибись. Ниче что ни один здравомыслящий программист для аккумулирования строки не станет юзать string, а использует предназначенный для этого инструмент — StringBuilder?

H>Ты хоть читай немного, перед тем, как в эфир выходишь

А ты хоть немного думай. Пишешь всякую чушь.

kuj>>А то давай напишем что-то вроде

kuj>>for(int i=0; i<n; i++) { MyObj obj = new MyObj(); }

kuj>>и "идентичный алгоритм" на Delphi

kuj>>for i:=1 to n do obj := MyObj.Create;

kuj>>на пару сотен миллионов итераций и сравним использование памяти ;]

H>Алгоритм идентичен, только ты мусор вынести забыл.

Ничего я не забыл. По твоей же логике. ;]

Дошло какую чушь ты несешь?

Алгоритм описывает последовательность действий, но при этом детали реализации этой в разных языках, ессесно, разнятся. Короче, хаттаб, полный слив тебе засчитан.

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

H>>>А-а-а, так ты за сравнение mov ax, bx... Удачи.

Y>>Тебе намекают на то, что идентичностью в твоем примере нет. В Delphi ты используешь сущность реализующую мутабельную строку. В шарпе — имутабельную. В шарпе для мутабельной строки есть другая сущность. Так что идентичностью в твоем примере и не пахнет. И если 2 разные сущности обозначаются одним и тем же именем — класс String в твоем случае (это на что тебе jenyavb намекал выделяя слово выглядеть) это еще не значи, что они одинаковы.

H>Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен

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

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

H>>Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен -- конкатенация выполнена естественным способом), неидентична выполняемая работа всилу различной реализации базовых типов (но где, блин, граница, а? mov ax, bx? Чудно!). Ну сколько можно???

Y>Говоря про естественность ты имеешь в виду выглядит одинаково? Твоя реализация алгоритма выглядит неестественно для C#, если что.

Говоря о естественности, я в первую очередь говорю о том, что строки таки складываются со строками. Мутабельные они или нет, важно лишь для .NET.

Y>Еще раз: задача была привести аналогичные алгоритмы, а не алгоритмы, кажущиеся естественными тебе или алгоритмы использующие базовые типы (StringBuilder находиться в Base Class Library, если что).
Y>А теперь давай по простому, может тогда поймешь:
Y>Ты привел 2 алгоритма. Первый произовдит конкатенацию мутабелных строк в Delphi, второй — конкатенацию имутабелных строк в C#. Где аналогичность алгоритмов?
Y>Аналогичными будут конкатенация мутабельных строк в Delphi и мутабельных строк в C#. В С# мутабелная строка выражаеться классом StringBuilder.

StringBuilder это спец. заточка на перформанс ценой мемори-оверхеда. В Delphi все строки плоские, с оверхедом 14 байт. И ты мне говоришь, что это будет идентичное сравнение

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

kuj>>>А то давай напишем что-то вроде

kuj>>>for(int i=0; i<n; i++) { MyObj obj = new MyObj(); }

kuj>>>и "идентичный алгоритм" на Delphi

kuj>>>for i:=1 to n do obj := MyObj.Create;

kuj>>>на пару сотен миллионов итераций и сравним использование памяти ;]

H>>Алгоритм идентичен, только ты мусор вынести забыл.

kuj>Ничего я не забыл. По твоей же логике. ;]

kuj>Дошло какую чушь ты несешь?

kuj>Алгоритм описывает последовательность действий, но при этом детали реализации этой в разных языках, ессесно, разнятся. Короче, хаттаб, полный слив тебе засчитан.

Наконец до тебя дошло. Мои поздравления. Ничего, что я об этом раз десять уже написал?

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

H>>>>А-а-а, так ты за сравнение mov ax, bx... Удачи.

Y>>>Тебе намекают на то, что идентичностью в твоем примере нет. В Delphi ты используешь сущность реализующую мутабельную строку. В шарпе — имутабельную. В шарпе для мутабельной строки есть другая сущность. Так что идентичностью в твоем примере и не пахнет. И если 2 разные сущности обозначаются одним и тем же именем — класс String в твоем случае (это на что тебе jenyavb намекал выделяя слово выглядеть) это еще не значи, что они одинаковы.

H>>Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен

C>Алгоритм-то может и идентичен, но реализация алгоритма на С# выполнена некорректно. Конечно, если так писать, как пишете Вы (по-индусски), то будет за что ругать дотнет (вернее только тем, кто не видел как написан код).

Для тех кто не понял, я повторю еще раз: это был пример демонстрирующий всю бессмысленность стремления к идентичности алгоритмов, ибо вот такие детали реализаций будут торчать изо всех щелей.

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

H>>>Я уже несколько раз написал, что при идентичности алгоритма (а он таки идентичен

C>>Алгоритм-то может и идентичен, но реализация алгоритма на С# выполнена некорректно. Конечно, если так писать, как пишете Вы (по-индусски), то будет за что ругать дотнет (вернее только тем, кто не видел как написан код).

H>Для тех кто не понял, я повторю еще раз: это был пример демонстрирующий всю бессмысленность стремления к идентичности алгоритмов, ибо вот такие детали реализаций будут торчать изо всех щелей.

Ну это глупости. Если вместо string использовать StringBuilder, то алгоритм от этого не поменяется. Поменяется способ реализации алгоритма. Вы, например, знаете что такое "рефакторинг"? Если знаете, то поймете что я имею в виду...