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

_FR>И как быть, когда тип поля (_field) — это enum MyEnum?

Проблема яйца выеденного не стоит. Надо сделать свойство: MyEnum Field { get { return (MyEnum) _field; } }

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

L>>Сорри, тут ступил.

JR>Бывает. Но у меня к Вам личная просьба — нельзя-ли формулировать Ваши сомнения или вопросы, несколько более корректно, не предполагая самой формулировкой, что Ваш собеседник — дурак?

Уважаемый, это вообще-то вы с FRED-ом влезли со своей демонстрацией ума, не я, так что примените свой совет прежде всего к себе самому.

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

А>Понял. А если я просто читаю поле (не свойство) то его не нужно лочить?

Если его размер равен 4-м байт(как в Вашем примере), то не нужно. Даже если кто-то будет его писать в этот момент, ничего страшного не произойдёт. Стоит только пометить переменную как volatile.

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

А>Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?

Метод IsSet — потокобезопасен, т.к. там присутствует только одно чтение, а оно безопасно.

Методы OnSet, OfSet — непотокобезопасны, т.к. там присутствует как чтение, так и запись и между ними может вклиниться другой поток. Поэтому, тело метода луче обрамить в lock(_lock), а _lock нужно объявить членом класса (private readonly object _lock = new object().
Сами методы OnSet, OfSet реализованы неправильно, для манипуляции flag-ами нужно использовать битовые операции.

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

_FR>>>Это зависит от того, как реализовано get. Что бы лишний раз не думать, можно и залочить.
А>>Понял. А если я просто читаю поле (не свойство) то его не нужно лочить?
TK>В случае с вашим кодом (использование enum) можно использовать Interlocked операции для записи изменений и обычное чтение без дополнительных блокировок.

А разве можно на Interlocked сделать добавление/удаление флага?

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

А>>Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?
L>Метод IsSet — потокобезопасен, т.к. там присутствует только одно чтение, а оно безопасно.

А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?

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

L>И где ты это нашел?

В смысле? Если Вы имеете в виду приведённый ТС пример, то ведь очевидно, что это просто демонстрация вопроса. Просто утверждение

Метод IsSet — потокобезопасен, т.к. там присутствует только одно чтение, а оно безопасно.

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

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

JR>>Бывает. Но у меня к Вам личная просьба — нельзя-ли формулировать Ваши сомнения или вопросы, несколько более корректно, не предполагая самой формулировкой, что Ваш собеседник — дурак?

L>Уважаемый, это вообще-то вы с FRED-ом влезли со своей демонстрацией ума, не я, так что примените свой совет прежде всего к себе самому.

Печально, когда на простой вопрос "А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?" вместо того, что бы просто ответить "не, не будет" или "всё равно будет", начинают говорить, что вот "влезли" и прочие неприятные слова

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

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

L>>Уважаемый, это вообще-то вы с FRED-ом влезли со своей демонстрацией ума, не я, так что примените свой совет прежде всего к себе самому.

_FR>Печально, когда на простой вопрос "А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?" вместо того, что бы просто ответить "не, не будет" или "всё равно будет",

Про восьмибайтный enum я ответил достаточно предсказуемо, не так ли?

_FR>начинают говорить, что вот "влезли" и прочие неприятные слова

А тут пошло передергивание, т.к. ответ про "влезли" был уже в совсем другом месте.

_FR>Как будто, что показалось, что своим вопросом я хотел кого-то оскорбить Никуда я не влезал. Я задал вопрос. А вот вы, вместо ответа на него, повели себя не достойно, начав оправдываться,

Оправдываться?

А где ты нашел восьмибайтный enum?

Есть множество

[Flags]
public enum MySet{None=0,Val1=1,Val1=2,Val3=4}

И нужны функции которые будут работать в многопоточном коде. Вот они
private MySet mySet;
public bool IsSet(MySet s)
{
 return mySet & s == s;
}
public void OnSet(MySet s)
{
 mySet += s;
}

public void OfSet(MySet s)
{
 mySet -= s;
}

Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?

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

А>Есть множество
…
А>И нужны функции которые будут работать в многопоточном коде. Вот они
…
А>Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?

Нужно использовать тег [c#], битовые опрерации сложения и умножения и, например, lock.

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

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

А>>Есть множество
_FR>…
А>>И нужны функции которые будут работать в многопоточном коде. Вот они
_FR>…
А>>Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?

_FR>Нужно использовать тег [c#], битовые опрерации сложения и умножения и, например, lock.

Извините за наглость, а код не покажете? Только начинаю писать и не хочется на грабли наступать в такой мелочи

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

А>>>Есть множество
_FR>>…
А>>>И нужны функции которые будут работать в многопоточном коде. Вот они
_FR>>…
А>>>Как такое сделать в многопоточной среде? Или можно оставить так и проблем не будет?
_FR>>Нужно использовать тег [c#], битовые опрерации сложения и умножения и, например, lock.

А>Извините за наглость, а код не покажете? Только начинаю писать и не хочется на грабли наступать в такой мелочи

Типы перечислений (руководство по программированию в C#)
lock Statement (C# Reference)

А>>Извините за наглость, а код не покажете? Только начинаю писать и не хочется на грабли наступать в такой мелочи

_FR>Типы перечислений (руководство по программированию в C#)
_FR>lock Statement (C# Reference)

Спасибо. А подскажите. Есть я делаю Read-Only свойство то в методе get мне надо использовать lock?

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

А>>>Извините за наглость, а код не покажете? Только начинаю писать и не хочется на грабли наступать в такой мелочи

_FR>>Типы перечислений (руководство по программированию в C#)
_FR>>lock Statement (C# Reference)

А>Спасибо. А подскажите. Есть я делаю Read-Only свойство то в методе get мне надо использовать lock?

Это зависит от того, как реализовано get. Что бы лишний раз не думать, можно и залочить.

_FR>Это зависит от того, как реализовано get. Что бы лишний раз не думать, можно и залочить.
Понял. А если я просто читаю поле (не свойство) то его не нужно лочить?

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

_FR>>Это зависит от того, как реализовано get. Что бы лишний раз не думать, можно и залочить.
А>Понял. А если я просто читаю поле (не свойство) то его не нужно лочить?

В случае с вашим кодом (использование enum) можно использовать Interlocked операции для записи изменений и обычное чтение без дополнительных блокировок.

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

А>>Понял. А если я просто читаю поле (не свойство) то его не нужно лочить?

TK>В случае с вашим кодом (использование enum) можно использовать Interlocked операции для записи изменений и обычное чтение без дополнительных блокировок.

А можно пример использоания interlocked в применении к данному случаю?

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

L>>Метод IsSet — потокобезопасен, т.к. там присутствует только одно чтение, а оно безопасно.

_FR>А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?

А где ты нашел восьмибайтный enum?

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

_FR>А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?
+1

И даже если 4-хбайтный, но не выровнен на границу (нарпимер при Pack == 1), то тоже может оказаться непотокобезопасным.

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

L>А где ты нашел восьмибайтный enum?

enum MyEnum: long

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

_FR>А разве можно на Interlocked сделать добавление/удаление флага?

Можно с применением Interlocked.CompareExchange

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

L>>А где ты нашел восьмибайтный enum?

JR>

JR>enum MyEnum: long
JR>

JR>

И где ты это нашел?

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

JR>Просто утверждение

JR>

JR>Метод IsSet — потокобезопасен, т.к. там присутствует только одно чтение, а оно безопасно.

JR>слишком жёстко на мой взгляд, так как его справедливость зависит от ряда дополнительных, неоговоренных условий.

Я даже более скажу, любое утвердение без контекста теряет смысл. А контекст определен топиком.

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

_FR>>А разве можно на Interlocked сделать добавление/удаление флага?

JR>Можно с применением Interlocked.CompareExchange

Ну ты пример все-таки приведи. Относяшийся к топику.

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

_FR>>А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?
JR>+1

JR>И даже если 4-хбайтный, но не выровнен на границу (нарпимер при Pack == 1), то тоже может оказаться непотокобезопасным.

Да ну, выходит спека нагло врет?

Reads and writes of the following data types are atomic: bool, char, byte, sbyte, short, ushort, uint, int, float, and reference types. In addition, reads and writes of enum types with an underlying type in the previous list are also atomic. Reads and writes of other types, including long, ulong, double, and decimal, as well as user-defined types, are not guaranteed to be atomic.

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

TK>>В случае с вашим кодом (использование enum) можно использовать Interlocked операции для записи изменений и обычное чтение без дополнительных блокировок.

L>А можно пример использоания interlocked в применении к данному случаю?

Как было предложено выше, надо использовать Interlocked.CompareExchange — делается цикл результатом выхода из которого является установленный / сброшенный флаг.

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

L>Здравствуйте, Jolly Roger, Вы писали:

_FR>>>А если у енама underlying-тип — восьмибайтный, тоже будет "безопасно"?
JR>>+1

JR>>И даже если 4-хбайтный, но не выровнен на границу (нарпимер при Pack == 1), то тоже может оказаться непотокобезопасным.

L>Да ну, выходит спека нагло врет?
L>

L>Reads and writes of the following data types are atomic: bool, char, byte, sbyte, short, ushort, uint, int, float, and reference types. In addition, reads and writes of enum types with an underlying type in the previous list are also atomic. Reads and writes of other types, including long, ulong, double, and decimal, as well as user-defined types, are not guaranteed to be atomic.

Вот тут интересная статейка:
http://www.albahari.com/threading/part4.aspx

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

L>Ну ты пример все-таки приведи. Относяшийся к топику.

Если уровень конкуренции не высок то, вполне достаточно подобного кода.

do 
{
   newValue = (MyEnum)Interlocked.CompareExchange(ref _field, _field | (int)MyEnum.Flag, _field);
} while((newValue & MyEnum.Flag) != MyEnum.Flag);

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

L>>Ну ты пример все-таки приведи. Относяшийся к топику.
TK>Если уровень конкуренции не высок то, вполне достаточно подобного кода.

TK>do 
TK>{
TK>   newValue = (MyEnum)Interlocked.CompareExchange(ref _field, _field | (int)MyEnum.Flag, _field);
TK>} while((newValue & MyEnum.Flag) != MyEnum.Flag);

И как быть, когда тип поля (_field) — это enum MyEnum?

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

L>Ну ты пример все-таки приведи. Относяшийся к топику.

private int _mySet;
public MySet mySet { get { return (MySet)_mySet; } }
public bool IsSet(MySet s)
{
    return (_mySet & (int)s) != 0;
}
public void OnSet(MySet s)
{
    var tmp = _mySet;
    for (; ; )
    {
        var tmp2 = tmp;
        var newVal = tmp | (int)s;
        tmp = Interlocked.CompareExchange(ref _mySet, newVal, tmp);
        if (tmp == tmp2) return;
    }
}

С методом OfSet справитесь, думаю, сами?

L>Да ну, выходит спека нагло врет?

Блажен, кто верует (с)

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

_FR>И как быть, когда тип поля (_field) — это enum MyEnum?

Переименовать его в int?

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

L>>Ну ты пример все-таки приведи. Относяшийся к топику.


JR>

JR>private int _mySet;
JR>public MySet mySet { get { return (MySet)_mySet; } }
JR>public bool IsSet(MySet s)
JR>{
JR>    return (_mySet & (int)s) != 0;
JR>}
JR>public void OnSet(MySet s)
JR>{
JR>    var tmp = _mySet;
JR>    for (; ; )
JR>    {
JR>        var tmp2 = tmp;
JR>        var newVal = tmp | (int)s;
JR>        tmp = Interlocked.CompareExchange(ref _mySet, newVal, tmp);
JR>        if (tmp == tmp2) return;
JR>    }
JR>}
JR>

А зачем тут приведение к int-у? Чтобы умнее выглядело?

L>>Да ну, выходит спека нагло врет?

JR>

JR>Блажен, кто верует (с)

Т.е. таки врет?

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

L>А зачем тут приведение к int-у? Чтобы умнее выглядело?

Сорри, тут ступил.

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

L>Т.е. таки врет?

Скорее не врёт, но не охватывает всех возможных ситуаций. Пока Вы пользуетесь дефолтным выравниванием, это утверждение справедливо. Если-же Вы испльзуете Pack, то выравнивание задаётся этим аттрибутом. В этом случае половина int может оказаться, например, в одной 32-хбайтной группе, а другая — в другой. В этих условиях чтение такой переменной вполне может оказаться неатомарным, так как процессору потребуется два обращения к шине для её считывания.

PS Я рад, что это Вас веселит.

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

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

L>>А зачем тут приведение к int-у? Чтобы умнее выглядело?

L>Сорри, тут ступил.

Бывает. Но у меня к Вам личная просьба — нельзя-ли формулировать Ваши сомнения или вопросы, несколько более корректно, не предполагая самой формулировкой, что Ваш собеседник — дурак? Ведь даже если он ошибается, это ведь ещё не повод, верно? Ведь каждый может ошибиться, вот как Вы, например

Спасибо.

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

JR>Скорее не врёт, но не охватывает всех возможных ситуаций. Пока Вы пользуетесь дефолтным выравниванием, это утверждение справедливо. Если-же Вы испльзуете Pack, то выравнивание задаётся этим аттрибутом. В этом случае половина int может оказаться, например, в одной 32-хбайтной группе, а другая — в другой. В этих условиях чтение такой переменной вполне может оказаться неатомарным, так как процессору потребуется два обращения к шине для её считывания.

Подтверждения конечно же не будет?

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

L>Подтверждения конечно же не будет?

Нет, не будет. Если это Вас интересует, воспользуйтесь гуглем. Например, поинтересуйтесь, почему нативные Interlocked-функции оперируют только выровненными на 4-хбайтную границу переменными.

Или не интересуйтесь, мне всё равно.