Действительно ли это - хороший дизайн для создания безопасных от нити классов в C#?

имейте в виду, что термин «безопасный резьб» не является конкретным; То, что вы делаете здесь, будет более точно называться «синхронизацией» с помощью монитора блокировки .

Это сказал, что извлеченность вокруг синхронизированного кода в значительной степени неизбежно. Вы могли бы сократить на одном из пробелов в вашем примере, поворачивая такие вещи:

lock (theLock)
{
    propertyB = value;
}

в это:

lock (theLock) propertyB = value;

относительно того, является ли это правильно для вас, нам действительно нужно больше информации Отказ Синхронизация - это только один подход к «Безопасности потоков»; Неподвижные объекты, семафоры и т. Д. - все разные механизмы, которые соответствуют различным случаям использования. Для простого примера вы предоставляете (где он выглядит так, как будто вы пытаетесь обеспечить атомность получить работу или установить операцию), то похоже, что вы сделали правильные вещи, но если ваш код предназначен для более Иллюстрация, чем пример, то все может быть не так просто.

Поскольку больше нет, кажется, не делает его, вот какой-то анализ вашего конкретного дизайна.

• Хотите прочитать любое единственное свойство? Threadsafe
• Хотите обновить в любое одностороннее свойство? ThreadsAfe
• Хотите прочитать одно свойство, а затем обновить его на основе его исходного значения? Не ThreadSafe

Thread 2 может обновить значение между нитью 1 чтение и обновление.

• Хотите обновить две связанные свойства одновременно? Не ThreadsAfe

Вы можете в конечном итоге с свойством имеете значение Thread 1 и свойство B, имеющие резьбу 2-качества.

1. Тема 1 Обновление
2. Тема 2 Обновить
3. Нить 1 Обновление B

4. Тема 2 Обновить B

   • Хотите прочитать два связанных свойства одновременно? Не ThreadSafe

Опять же, вы можете быть прерваны между первым и вторым чтением.

Я мог бы продолжать, но вы получите идею. Threadsafence чисто основана на том, как вы планируете получить доступ к объектам и какие обещания вам нужно сделать.

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

Согласно моему комментарию выше - он получает немного волосы, если вы хотите, чтобы одновременные читатели разрешены, но только один писатель разрешен. Примечание, если у вас есть .NET 3.5, используйте ReaderWriterLockSlim , а не ReaderWriterLock для этого типа шаблона.

public class ThreadSafeClass
{
    private readonly ReaderWriterLock theLock = new ReaderWriterLock();

    private double propertyA;
    public double PropertyA
    {
        get
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                return propertyA;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        set
        {
            theLock.AcquireWriterLock(Timeout.Infinite);
            try
            {
                propertyA = value;
            }
            finally
            {
                theLock.ReleaseWriterLock();
            }
        }
    }

    private double propertyB;
    public double PropertyB
    {
        get
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                return propertyB;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        set
        {
            theLock.AcquireWriterLock(Timeout.Infinite);
            try
            {
                propertyB = value;
            }
            finally
            {
                theLock.ReleaseWriterLock();
            }
        }
    }

    public void SomeMethod()
    {
        theLock.AcquireWriterLock(Timeout.Infinite);
        try
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                PropertyA = 2.0 * PropertyB;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        finally
        {
            theLock.ReleaseWriterLock();
        }
    }
}

Вы можете найти блокировку класс полезным. Он содержит несколько атомных операций.

Самый простой способ - если известен тип сборки, на которую имеется ссылка:

AssemblyName name = typeof(MyCompany.MyLibrary.SomeType).Assembly.GetName();

Assembly.GetName возвращает значение AssemblyName , которое имеет свойство Version , указывающее версию сборки.

Кроме того, можно получить имена всех сборок, на которые ссылается исполняющая сборка (т.е. .exe):

AssemblyName[] names = Assembly.GetExecutingAssembly().GetReferencedAssemblies();

Чтобы ответить на сборочную часть вопроса, сборка не компилируется в двоичный файл, как я понимаю. Сборка = = = двоичная. Это прямо переводится. Каждая операция сборки имеет двоичную последовательность, которая непосредственно соответствует ей. Каждая операция имеет двоичный код, а каждая переменная регистра имеет двоичный адрес.

То есть, если только Assembler! = Assembly и я не понимаю ваш вопрос.

Я знаю, что это может звучать как умный ответ * *, но... ЛУЧШИЙ способ разработки классов threadsafe состоит в том, чтобы на самом деле знать о многопоточности, о ее последствиях, ее тонкостях и о том, что она подразумевает. Там нет серебряной пули.

• Сначала вам нужна веская причина, чтобы использовать его . Нити - это инструмент, вы не хотите бить все своим новым найденным молотком.
• Во-вторых, узнайте о проблемах многопоточности... взаимоблокировки , расовые условия , голодание и так далее
• В-третьих, убедитесь, что это того стоит. Я говорю о преимуществах/затратах.
• Наконец-то... быть готовым к тяжелой отладке. Отладка многопоточного кода намного сложнее, чем стандартный старый последовательный код. Узнайте несколько методов, как это сделать.

Серьезно... не пытайтесь использовать многопоточность (в производственных сценариях, я имею в виду), пока не поймете, во что вы ввязываетесь... Это может быть огромной ошибкой.

Изменить: Вы, конечно, должны знать примитивы синхронизации как операционной системы, так и языка выбора (в данном случае C # под Windows, я полагаю).

Мне жаль, что я не даю просто код, чтобы просто сделать класс threadsafe. Это потому, что он не существует . Совершенно threadsafe класс, вероятно, будет просто медленнее, чем просто избежать потоков и, вероятно, будет действовать как узкое место для того, что вы делаете... эффективно отменяя все, чего вы добиваетесь, используя потоки.