Добрый день. Простите за тупой вопрос. Есть константы слудующего вида
1. Используются только в одном классе но в нескольких местах
2. Используются в нескольких классах одной иерархии
3. Используются в нескольких не связанных классах

Как в Си шарп такие представить?

Здравствуйте, Аноним, Вы писали:

А>Добрый день. Простите за тупой вопрос. Есть константы слудующего вида
А>1. Используются только в одном классе но в нескольких местах

Закрытое поле класса.

class MyClass {
  private const string MyConstant = "Hello, Constant";
}

А>2. Используются в нескольких классах одной иерархии

Защищенное поле в базовом классе.

class MyBaseClass {
  protected const string MyProtectedConstant = "Hello, Protected Constant";
}

А>3. Используются в нескольких не связанных классах

Открытое поле в утилитном классе.

class MyUtilityClass {
  public const string MyPublicConstant = "Hello, Public Constant";
}

А>Как в Си шарп такие представить?

Здравствуйте, Аноним, Вы писали:

А>1. Используются только в одном классе но в нескольких местах

Как private const внутри класса.

А>2. Используются в нескольких классах одной иерархии

Как protected const внутри класса.

А>3. Используются в нескольких не связанных классах

Задать const в одном классе (к которому по смыслу ближе это значение), а потом передать как параметр конструктора в другие классы.

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

ST>Открытое поле в утилитном классе.

ST>

ST>class MyUtilityClass {
ST>  public const string MyPublicConstant = "Hello, Public Constant";
ST>}
ST>

Лучше так:

class MyUtilityClass {
public static string MyPublicConstant = "Hello, Public Constant";
}

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

K>Лучше так:
K>

K>class MyUtilityClass {
K>public static string MyPublicConstant = "Hello, Public Constant";
K>}
K>

Чем лучше?

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

А>>3. Используются в нескольких не связанных классах

Doc>Задать const в одном классе (к которому по смыслу ближе это значение), а потом передать как параметр конструктора в другие классы.

А потом долго и нудно дебажить на предмет откуда это значение появилось?
public const и прямое обращение — наше все.

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

K>Лучше так:
K>

K>class MyUtilityClass {
K>public static string MyPublicConstant = "Hello, Public Constant";
K>}
K>

Это не константа
const подразумевает static

Здравствуйте, Аноним, Вы писали:

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

K>>Лучше так:
K>>

K>>class MyUtilityClass {
K>>public static string MyPublicConstant = "Hello, Public Constant";
K>>}
K>>

А>Чем лучше?

Ничем, это неправильно.

Здравствуйте, Аноним, Вы писали:

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

K>>Лучше так:
K>>

K>>class MyUtilityClass {
K>>public static string MyPublicConstant = "Hello, Public Constant";
K>>}
K>>

А>Чем лучше?

Константы компилятор C# подставляет в код (инлайнит). В случае когда клиентский код скомпилирован с одной версией библиотеки, а выполняется с другой (например через технику bindingRedirect-а), в которой значение константы изменено, то он по прежнему будет использовать старое значение. Поэтому рекомендуется делать видимость констант не шире internal, а в случае когда к константе нужно получать доступ извне сборки — делать static readonly поле.

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

А>>Чем лучше?

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

Кэп?

H>Поэтому рекомендуется делать видимость констант не шире internal, а в случае когда к константе нужно получать доступ извне сборки — делать static readonly поле.

Это зависит от требований. Никаких общих рекомендаций тут давать нельзя.

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

H>Здравствуйте, Аноним, Вы писали:

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

K>>>Лучше так:
K>>>

K>>>class MyUtilityClass {
K>>>public static string MyPublicConstant = "Hello, Public Constant";
K>>>}
K>>>

А>>Чем лучше?

H>Константы компилятор C# подставляет в код (инлайнит). В случае когда клиентский код скомпилирован с одной версией библиотеки, а выполняется с другой (например через технику bindingRedirect-а), в которой значение константы изменено, то он по прежнему будет использовать старое значение. Поэтому рекомендуется делать видимость констант не шире internal, а в случае когда к константе нужно получать доступ извне сборки — делать static readonly поле.

Лучше не доводить до такого, либо использовать свойства, а не поля.

Здравствуйте, Аноним, Вы писали:

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

А>>>Чем лучше?

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

А>Кэп?

H>>Поэтому рекомендуется делать видимость констант не шире internal, а в случае когда к константе нужно получать доступ извне сборки — делать static readonly поле.

А>Это зависит от требований. Никаких общих рекомендаций тут давать нельзя.

Можно, например для использования в других сборках — пользуем свойства.

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

VN>Лучше не доводить до такого, либо использовать свойства, а не поля.

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

Здравствуйте, Аноним, Вы писали:

А>Это зависит от требований. Никаких общих рекомендаций тут давать нельзя.

Требований на объявление констант?

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

А>>Это зависит от требований. Никаких общих рекомендаций тут давать нельзя.

H>Требований на объявление констант?

Истерика? Скажи, например, зачем String.Empty объявлять не-константой? Что такое должно произойти, чтобы это значение изменилось?

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

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

VN>>Лучше не доводить до такого, либо использовать свойства, а не поля.

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

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

Здравствуйте, Аноним, Вы писали:

А>Истерика? Скажи, например, зачем String.Empty объявлять не-константой? Что такое должно произойти, чтобы это значение изменилось?

Бывает так что константы не пустые строки (имена какие-нибудь) — в этом случае вероятность их изменения ой как далека от нуля.

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

А>>Истерика? Скажи, например, зачем String.Empty объявлять не-константой? Что такое должно произойти, чтобы это значение изменилось?

H>Бывает так что константы не пустые строки (имена какие-нибудь) — в этом случае вероятность их изменения ой как далека от нуля.

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

Это зависит от требований.

Здравствуйте, Аноним, Вы писали:

А>А потом долго и нудно дебажить на предмет откуда это значение появилось?
А>public const и прямое обращение — наше все.

Если нудно — то это проблемы архитектуры и именования параметров. Любое значение в приложении должно нести смысл и принадлежать конкретной сущности, а не классу — сборнику констант. Ну и в описанном мной варианте избегаем проблемы появления потенциального God-object, да еще и static по сути.

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

Doc>Здравствуйте, Аноним, Вы писали:

А>>А потом долго и нудно дебажить на предмет откуда это значение появилось?
А>>public const и прямое обращение — наше все.

Doc>Если нудно — то это проблемы архитектуры и именования параметров. Любое значение в приложении должно нести смысл и принадлежать конкретной сущности, а не классу — сборнику констант. Ну и в описанном мной варианте избегаем проблемы появления потенциального God-object, да еще и static по сути.

Что такое StringSplitOptions? То что это enum — значения не имеет, но почему он обьявлен отдельно от класса String?

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

VN>Что такое StringSplitOptions? То что это enum — значения не имеет, но почему он обьявлен отдельно от класса String?

Как это не имеет? Сравнивать Enum и const это как сравнивать красное с теплым.

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>Что такое StringSplitOptions? То что это enum — значения не имеет, но почему он обьявлен отдельно от класса String?

Doc>Как это не имеет? Сравнивать Enum и const это как сравнивать красное с теплым.

Enum это набор констант. Только почему нет такого как String.RemoveEmptyEntities? Вынесли, и все тут. Даже не Split(..., bool removeEmptyEntities). A?

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

VN>Enum это набор констант.

Ну вот вы и ответили себе. Я говорил про единичные значения.
Но если у вас есть свой ответ — интересно было бы узнать мне мнение.

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>Enum это набор констант.

Doc>Ну вот вы и ответили себе. Я говорил про единичные значения.
Doc>Но если у вас есть свой ответ — интересно было бы узнать мне мнение.

Любое значение в приложении должно нести смысл и принадлежать конкретной сущности, а не классу — сборнику констант. Ну и в описанном мной варианте избегаем проблемы появления потенциального God-object, да еще и static по сути.

Если у ТС есть пара-тройка констант которые используются в паре-тройке классов (не в одной иерархии), то вполне логично вывести их в отдельный класс. Ну и вполне логично, что те классы где эти константы используются — не походят, потому как скорее всего не будет однозначной принадлежности к какому-то классу. Никто кстати не говорит о God-object — константы группируются по смыслу, и эти группы используются только в ограниченном количестве сущностей. Как пример: StringSplitOptions.

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

VN>Ну и вполне логично, что те классы где эти константы используются — не походят, потому как скорее всего не будет однозначной принадлежности к какому-то классу.

Это как? Любая константа имеет свой физический смысл. Число циклов, адрес порта, время задержки и т. д. Ну и как частный случай — класс конфигурации, если предполагается что в будующем она будет меняться. Но опять же — наружу в этом случае будет торчать интерфейс или хотябы просто проперти класса.

VN>Никто кстати не говорит о God-object — константы группируются по смыслу, и эти группы используются только в ограниченном количестве сущностей. Как пример: StringSplitOptions.

Вы так и не дали пояснения почему StringSplitOptions отдельная от String сущность? Почему это лучше чем String.SplitOptions.RemoveEmptyEntries?

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>Ну и вполне логично, что те классы где эти константы используются — не походят, потому как скорее всего не будет однозначной принадлежности к какому-то классу.

Doc>Это как? Любая константа имеет свой физический смысл. Число циклов, адрес порта, время задержки и т. д. Ну и как частный случай — класс конфигурации, если предполагается что в будующем она будет меняться. Но опять же — наружу в этом случае будет торчать интерфейс или хотябы просто проперти класса.

VN>>Никто кстати не говорит о God-object — константы группируются по смыслу, и эти группы используются только в ограниченном количестве сущностей. Как пример: StringSplitOptions.

Doc>Вы так и не дали пояснения почему StringSplitOptions отдельная от String сущность? Почему это лучше чем String.SplitOptions.RemoveEmptyEntries?

Сколько классов зависят от этих констант?
Будешь ли ты использовать вложенные классы?

Ответы на эти вопросы отвечают и на твой.

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

VN>Сколько классов зависят от этих констант?
В общем случае неизвестно.

VN>Будешь ли ты использовать вложенные классы?
А причем тут я? Мы говорили про enum из .NET

VN>Ответы на эти вопросы отвечают и на твой.

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

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

VN>>Сколько классов зависят от этих констант?
Doc>В общем случае неизвестно.
Т. е. много.

VN>>Будешь ли ты использовать вложенные классы?
Doc>А причем тут я? Мы говорили про enum из .NET
Ну или вложенный публичный enum.
Я не стал бы.

VN>>Ответы на эти вопросы отвечают и на твой.
Мой ответ: Поскольку у нас много зависимых классов и вложенный публичный класс ( ) я делать не буду, то надо выность константы в отдельный класс.

Doc>Ответов как я понимаю нет. Тем более, что для того чтобы доказать свою позицию вы с констант переключились на enum. Последние все же по сути ближе к обычным переменным, т.к. это тип с ограниченным диапазоном значений.

Сравни:

public static class SomeEnums
{
  public const int EnumValue0 = 0;
  public const int EnumValue1 = 1;
  // ...
}

Да, enum это тип с ограниченным диапазоном значений. Но эти значения — константы. Могу привести пример с System.Drawing.Colors. Это статический класс с известными цветами. Они правда не const поля, но это уже ограничения .NET.
Но суть enum'ов остается та-же что и у констант.

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

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

VN>>>Сколько классов зависят от этих констант?
Doc>>В общем случае неизвестно.
VN>Т. е. много.

Это справедливо для любого public объекта.

VN>>>Ответы на эти вопросы отвечают и на твой.
VN>Мой ответ: Поскольку у нас много зависимых классов и вложенный публичный класс ( ) я делать не буду, то надо выность константы в отдельный класс.

И зачем нам лишние сущности?

VN>Да, enum это тип с ограниченным диапазоном значений. Но эти значения — константы.

Ага, а int это тоже тип с ограниченным диапазоном значений и эти значения константы. Выходит int — как константа.

VN>Могу привести пример с System.Drawing.Colors. Это статический класс с известными цветами. Они правда не const поля, но это уже ограничения .NET.

Ага, все что не вписывается в доказательство — не существенно, ограничения и т.д.

VN>Но суть enum'ов остается та-же что и у констант.

... и int (т.е. это как и enum ... см. выше)? Все же давайте отличать само значение (const) от типа (enum).

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

Doc>Здравствуйте, vvlad.net, Вы писали:

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

VN>>>>Сколько классов зависят от этих констант?
Doc>>>В общем случае неизвестно.
VN>>Т. е. много.

Doc>Это справедливо для любого public объекта.

VN>>>>Ответы на эти вопросы отвечают и на твой.
VN>>Мой ответ: Поскольку у нас много зависимых классов и вложенный публичный класс ( ) я делать не буду, то надо выность константы в отдельный класс.

Doc>И зачем нам лишние сущности?

VN>>Да, enum это тип с ограниченным диапазоном значений. Но эти значения — константы.

Doc>Ага, а int это тоже тип с ограниченным диапазоном значений и эти значения константы. Выходит int — как константа.
Что такое enum в .NET? Описание в студию.

VN>>Могу привести пример с System.Drawing.Colors. Это статический класс с известными цветами. Они правда не const поля, но это уже ограничения .NET.

Doc>Ага, все что не вписывается в доказательство — не существенно, ограничения и т.д.
Мы не можем определить тип Color как const. Если бы могли — определили бы. А так просто свойство без setter'а

VN>>Но суть enum'ов остается та-же что и у констант.

Doc>... и int (т.е. это как и enum ... см. выше)? Все же давайте отличать само значение (const) от типа (enum).
см. выше. И еще, что нам даст:
1. (int)StringSplitOptions.RemoveEmptyEntities
2. String.Split(..., (StringSplitOptions)1)

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

Doc>Здравствуйте, vvlad.net, Вы писали:

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

VN>>>>Сколько классов зависят от этих констант?
Doc>>>В общем случае неизвестно.
VN>>Т. е. много.

Doc>Это справедливо для любого public объекта.

VN>>>>Ответы на эти вопросы отвечают и на твой.
VN>>Мой ответ: Поскольку у нас много зависимых классов и вложенный публичный класс ( ) я делать не буду, то надо выность константы в отдельный класс.

Doc>И зачем нам лишние сущности?
Это серьезный вопрос. Но сначала ответь чем тебе мешает еще одна сущность в конкретной ситуации? И что ты монимаешь под сущностью?

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

VN>>>Да, enum это тип с ограниченным диапазоном значений. Но эти значения — константы.
Doc>>Ага, а int это тоже тип с ограниченным диапазоном значений и эти значения константы. Выходит int — как константа.
VN>Что такое enum в .NET? Описание в студию.

The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list.

VN>Мы не можем определить тип Color как const. Если бы могли — определили бы. А так просто свойство без setter'а

Ну опять все в кучу. Это другая ситуация.

VN>>>Но суть enum'ов остается та-же что и у констант.

Doc>>... и int (т.е. это как и enum ... см. выше)? Все же давайте отличать само значение (const) от типа (enum).
VN>см. выше. И еще, что нам даст:
VN>1. (int)StringSplitOptions.RemoveEmptyEntities
VN>2. String.Split(..., (StringSplitOptions)1)

И что?
1. (int)String.SplitOptions.RemoveEmptyEntities
2. String.Split(..., (String.StringSplitOptions)1)

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

Doc>>И зачем нам лишние сущности?
VN>Это серьезный вопрос. Но сначала ответь чем тебе мешает еще одна сущность в конкретной ситуации?

А мы конкретную ситуацию разбираем? Просто чтобы сказать мешает или нет — надо саму ситуацию задать.

VN>И что ты монимаешь под сущностью?

В данном случае — класс.

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>>>Да, enum это тип с ограниченным диапазоном значений. Но эти значения — константы.
Doc>>>Ага, а int это тоже тип с ограниченным диапазоном значений и эти значения константы. Выходит int — как константа.
VN>>Что такое enum в .NET? Описание в студию.

Doc>The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list.

named constants

VN>>Мы не можем определить тип Color как const. Если бы могли — определили бы. А так просто свойство без setter'а

Doc>Ну опять все в кучу. Это другая ситуация.

какая другая? нам нужны константы описывающие цвета. они у нас есть. в классе Colors. в отдельном классе, не в классе Color, который описывает конкретный цвет.

VN>>>>Но суть enum'ов остается та-же что и у констант.

Doc>>>... и int (т.е. это как и enum ... см. выше)? Все же давайте отличать само значение (const) от типа (enum).
VN>>см. выше. И еще, что нам даст:
VN>>1. (int)StringSplitOptions.RemoveEmptyEntities
VN>>2. String.Split(..., (StringSplitOptions)1)

Doc>И что?
Doc>1. (int)String.SplitOptions.RemoveEmptyEntities
Doc>2. String.Split(..., (String.StringSplitOptions)1)

что за нафик?

1. будет 1. из енума. (как? почему? см. определение)
2. будет StringSplitOptions.RemoveEmptyEntities.

А твой ответ тут ни к чему. И я уже говорил о своем отношении (основанное на опыте) к публичным вложенным классам (и enum'ам и делегатам в частности). И вообще многие советуют избегать таких класов.

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

Doc>Здравствуйте, vvlad.net, Вы писали:

Doc>>>И зачем нам лишние сущности?
VN>>Это серьезный вопрос. Но сначала ответь чем тебе мешает еще одна сущность в конкретной ситуации?

Doc>А мы конкретную ситуацию разбираем? Просто чтобы сказать мешает или нет — надо саму ситуацию задать.

Конкретная ситуация: см. топик.

VN>>И что ты монимаешь под сущностью?

Doc>В данном случае — класс.

Сущность — это то что может выполнить определенную работу. Это какой-то класс и его вспомогательные классы (enum'ы, делегаты, хелперы). статический класс с константами — не сущность, так как он не выполняет какую-то работу, а просто группирует набор констант.

Для примера:
Есть у нас какой-то Reader и какой-то Writer. Они пишут строки в файл. Каждая строка должна начинаться с некого константного значения (или нескольких), от которых Reader зависит. Где ты будешь определять эти константы? в Reader'е или в Writer'е? Я сделаю отдельный класс. И подобные ситуации встречаются гораздо чаще, по сравнению с теми, где можно однозначно определить принадлежность констант.

ST>>

ST>>class MyUtilityClass {
ST>>  public const string MyPublicConstant = "Hello, Public Constant";
ST>>}
ST>>

K>Лучше так:
K>

K>class MyUtilityClass {
K>public static string MyPublicConstant = "Hello, Public Constant";
K>}
K>

К сожалению у меня юзаются конструкции вида [MyAttributeItem(MyUtilityClass.MyPublicConstant )] Поэтому я должен объявлять как константы. Статик тут не работает почему-то. Или я не прав?

Здравствуйте, Аноним, Вы писали:

ST>>>

ST>>>class MyUtilityClass {
ST>>>  public const string MyPublicConstant = "Hello, Public Constant";
ST>>>}
ST>>>

K>>Лучше так:
K>>

K>>class MyUtilityClass {
K>>public static string MyPublicConstant = "Hello, Public Constant";
K>>}
K>>

А>К сожалению у меня юзаются конструкции вида [MyAttributeItem(MyUtilityClass.MyPublicConstant )] Поэтому я должен объявлять как константы. Статик тут не работает почему-то. Или я не прав?

Прав, статик работать не будет.

К остальным в ветке: Опять const разруливает

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

VN>Конкретная ситуация: см. топик.

Это абстрактная ситуация. Более того, её уточнение в дальнейшем (про передачу значения в атрибуты) ввобще свело все к выбору между public const и enum. Причем тут enum даже больше подходит.

VN>Сущность — это то что может выполнить определенную работу. Это какой-то класс и его вспомогательные классы (enum'ы, делегаты, хелперы). статический класс с константами — не сущность, так как он не выполняет какую-то работу, а просто группирует набор констант.

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

VN>Для примера:
VN>Есть у нас какой-то Reader и какой-то Writer. Они пишут строки в файл. Каждая строка должна начинаться с некого константного значения (или нескольких), от которых Reader зависит. Где ты будешь определять эти константы? в Reader'е или в Writer'е? Я сделаю отдельный класс. И подобные ситуации встречаются гораздо чаще, по сравнению с теми, где можно однозначно определить принадлежность констант.

Вот уже конкретная задача. Но у меня несколько решений, в зависимости от общей цели:

1) Введение сущности "конвертор". Тогда reader и writer избавляются от знания формата и просто работают с определенным хранилищем. Такая схема позволяет сохранять в разные форматы и в разных хранилищах (диске, сети, инете по разным протоколам и т.д.)

2) Если формат один, то можно сделать Repository и скрыть все подробности работы внутри него. А он уже сам может настроить как надо чтение и запись.

3) Разместить данные о формате в конфигурации проекта (позволит настраивать эти символы в дальнейшем). Можно использовать с (2).

4) Ну и наконец, в редких случаях, если это что-то вроде признака уникодного файла (что не меняется в принципе), то можно и объявить private const в каждом классе. Т.к. если изменится этот признак, то и сами классы не будут работоспособны.

PS: Кстати, даже выбирая только между Reader и Writer (или там или там) можно дать ответ. Главный тут Writer. Т.к. именно он задает формат данных, а Reader должен прочитать уже существующее. Поэтому если хочется public const то можно сделать его в Writer.

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

VN>>>Что такое enum в .NET? Описание в студию.
Doc>>The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list.
VN>named constants

А не заметил of a set of ?

VN>А твой ответ тут ни к чему.

Стоп. Было сказано тобой

VN>>>см. выше. И еще, что нам даст: (далее код)

Я показал что тоже самое будет при вложенном enum. Так что все в тему.

VN>И я уже говорил о своем отношении (основанное на опыте) к публичным вложенным классам (и enum'ам и делегатам в частности). И вообще многие советуют избегать таких класов.

Упс... Ты определись. То говоришь что enum ближе к константам (ты выше bold-ом выделял), то вдруг к вложенным классам. Неувязочка

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

Doc>...

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

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>>>Что такое enum в .NET? Описание в студию.
Doc>>>The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list.
VN>>named constants

Doc>А не заметил of a set of ?

enum SomeEnums — это тип который содержит набор констант.
class SomeConstants — это тип который содержит набор констант.

Найди больше одного отличия...

VN>>А твой ответ тут ни к чему.

Doc>Стоп. Было сказано тобой

VN>>>>см. выше. И еще, что нам даст: (далее код)

Doc>Я показал что тоже самое будет при вложенном enum. Так что все в тему.

какая разница между вложенным enum и вложенным class?
Такая, что одно это enum, а другое это class.

какая разница между вложенным enum и const?
Ну нельзя сравнивать теплое с мягким...

VN>>И я уже говорил о своем отношении (основанное на опыте) к публичным вложенным классам (и enum'ам и делегатам в частности). И вообще многие советуют избегать таких класов.

Doc>Упс... Ты определись. То говоришь что enum ближе к константам (ты выше bold-ом выделял), то вдруг к вложенным классам. Неувязочка

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

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

VN>Много усложнизма... я не стал бы с самого начала создавать супер-пупер-гибкую структуру классов.

Ничего подобного. Просто по другому разделяем ответственности между классами. Большинство приложений в итоге оперируют не потоком символов, а именно "документами". От этого и исходим. Поэтому тот же "конвертор" из бинарных данных в классы все равно будет в приложении.

Про "усложнизм" в предложенных вариантах 3 и 4 это вообще анекдот.

VN>Здравый смысл подсказывает мне (и это работает), что не надо начинать со сложностей.

А потом вносить координаыльные изменения (например от Reader/Writer к репозиторию)?

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

VN>enum SomeEnums — это тип который содержит набор констант.
VN>class SomeConstants — это тип который содержит набор констант.
VN>Найди больше одного отличия...

Т.е. хочешь сказать отличий нет?

VN>какая разница между вложенным enum и const?
VN>Ну нельзя сравнивать теплое с мягким...

Вот, об этом я тебе и говорил.

VN>Читай и анализируй... я сравнивал enum с классом, который сожержит набор констант. Ну не стану я описывать константы в классе который занимается логикой. Привычка отделять мух от котлет.

Ну это ты уже сами котлеты делишь, на фрикадельки

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>Много усложнизма... я не стал бы с самого начала создавать супер-пупер-гибкую структуру классов.

Doc>Ничего подобного. Просто по другому разделяем ответственности между классами. Большинство приложений в итоге оперируют не потоком символов, а именно "документами". От этого и исходим. Поэтому тот же "конвертор" из бинарных данных в классы все равно будет в приложении.

Документ это класс который содержит данные, но ведь данные надо еще прочитать или записать. А это уже Reader/Writer. В принципе, в данном случае можно ставить конвертер — тогда мы забываем о публичных константах, что есть хорошо. Так?

А о чем собственно ветка? Про публичные константы.

Doc>Про "усложнизм" в предложенных вариантах 3 и 4 это вообще анекдот.

VN>>Здравый смысл подсказывает мне (и это работает), что не надо начинать со сложностей.

Doc>А потом вносить координаыльные изменения (например от Reader/Writer к репозиторию)?

А зачем переделывать? Репозиторий просто содержит эти Reader/Writer. Имеем опять же разделение ответственностей.

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>enum SomeEnums — это тип который содержит набор констант.
VN>>class SomeConstants — это тип который содержит набор констант.
VN>>Найди больше одного отличия...

Doc>Т.е. хочешь сказать отличий нет?

VN>>какая разница между вложенным enum и const?
VN>>Ну нельзя сравнивать теплое с мягким...

Doc>Вот, об этом я тебе и говорил.
А я об этом говорил с самого начала.

VN>>Читай и анализируй... я сравнивал enum с классом, который сожержит набор констант. Ну не стану я описывать константы в классе который занимается логикой. Привычка отделять мух от котлет.

Doc>Ну это ты уже сами котлеты делишь, на фрикадельки
Константы на фрикадельки не потянут. Так, крошки или мухи, это уже гораздо ближе. Ну а их и надо отделить. Заметь, что если бы константы использовались только в одном классе, то за пределами того класса их бы и не увидели, смотри тут

Автор: SergeyT.
Дата: 17.01.12

.

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

VN>Документ это класс который содержит данные, но ведь данные надо еще прочитать или записать. А это уже Reader/Writer. В принципе, в данном случае можно ставить конвертер — тогда мы забываем о публичных константах, что есть хорошо. Так?

Да.

VN>А о чем собственно ветка? Про публичные константы.

Да о них и их сокрытии. А так же об эффектах, возникающих например при замене сборки, где она объявлена.

Doc>>А потом вносить координаыльные изменения (например от Reader/Writer к репозиторию)?
VN>А зачем переделывать? Репозиторий просто содержит эти Reader/Writer. Имеем опять же разделение ответственностей.

Ну не содержит, а использует. А значит поменяется тип и интерфейс. Вот и переделки.

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

Doc>>Вот, об этом я тебе и говорил.
VN>А я об этом говорил с самого начала.

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

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

Doc>Здравствуйте, vvlad.net, Вы писали:

Doc>>>Вот, об этом я тебе и говорил.
VN>>А я об этом говорил с самого начала.

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

Значит недопонимание. Стоп. ТЧК

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

Doc>Здравствуйте, vvlad.net, Вы писали:

VN>>Документ это класс который содержит данные, но ведь данные надо еще прочитать или записать. А это уже Reader/Writer. В принципе, в данном случае можно ставить конвертер — тогда мы забываем о публичных константах, что есть хорошо. Так?

Doc>Да.

VN>>А о чем собственно ветка? Про публичные константы.

Doc>Да о них и их сокрытии. А так же об эффектах, возникающих например при замене сборки, где она объявлена.

Doc>>>А потом вносить координаыльные изменения (например от Reader/Writer к репозиторию)?
VN>>А зачем переделывать? Репозиторий просто содержит эти Reader/Writer. Имеем опять же разделение ответственностей.

Doc>Ну не содержит, а использует. А значит поменяется тип и интерфейс. Вот и переделки.

А если не поменяется?
premature generialization
преждевременное обобщение

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

Doc>>Ну не содержит, а использует. А значит поменяется тип и интерфейс. Вот и переделки.
VN>А если не поменяется?

Насчет вредности premature generialization не спорю. Но я изначально говорил что возможны варианты реализации.
В принципе, уже далеко ушли от темы. Предлагаю остаться при своих и закончить флеймить

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

Doc>Здравствуйте, vvlad.net, Вы писали:

Doc>>>Ну не содержит, а использует. А значит поменяется тип и интерфейс. Вот и переделки.
VN>>А если не поменяется?

Doc>Насчет вредности premature generialization не спорю. Но я изначально говорил что возможны варианты реализации.
Doc>В принципе, уже далеко ушли от темы. Предлагаю остаться при своих и закончить флеймить

Согласен. А тема была про общий случай, и понимание premature generialization позволяет избежать больших проблем.