Как соединить целое число в C#?

Мне нравится делать это следующим образом

public class Synchronizer {
    private Dictionary<int, object> locks;
    private object myLock;

    public Synchronizer() {
        locks = new Dictionary<int, object>();
        myLock = new object();
    }

    public object this[int index] {
        get {
            lock (myLock) {
                object result;
                if (locks.TryGetValue(index, out result))
                    return result;

                result = new object();
                locks[index] = result;
                return result;
            }
        }
    }
}

Затем, чтобы просто заблокировать int для вас (используя один и тот же синхронизатор каждый раз)

lock (sync[15]) { ... }

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

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

Вы должны использовать объект синхронизации следующим образом:

public class YourForm
{
    private static object syncObject = new object();

    public void Moderate()
    {
        lock(syncObject)
        {
            // do your business
        }
    }
}

Но этот подход не должен использоваться в сценарии веб-приложения.

В идеале вы можете избежать всей сложной и хрупкой блокировки C # и заменить ее блокировкой базы данных, если ваши транзакции спроектированы правильно, то вы сможете получить только с транзакциями БД.

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

Блокировка C # предназначена для обеспечения безопасности потоков и не работает так, как вы хотите, для веб-приложений.

Самое простое решение - добавить столбец в таблицу, которую вы хотите заблокировать, и когда somone блокируется, он пишет в БД, что этот столбец заблокирован.

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

В противном случае ведите статический список идентификаторов заблокированных записей и сравнивайте с этим. перед разрешением редактирования.

You need a whole different approach to this.

Remember that with a website, you don't actually have a live running application on the other side that responds to what the user does.

You basically start a mini-app, which returns the web-page, and then the server is done. That the user ends up sending some data back is a by-product, not a guarantee.

So, you need to lock to persist after the application has returned the moderation page back to the moderator, and then release it when the moderator is done.

And you need to handle some kind of timeout, what if the moderator closes his browser after getting the moderation page back, and thus never communicates back with the server that he/she is done with the moderation process for that post.

Я сомневаюсь, что вы должны использовать функцию уровня базы данных или O / S, такую ​​как блокировки, для решения бизнес-уровня. Блокировки влекут за собой значительные накладные расходы, если они удерживаются в течение длительного времени (и в этом контексте все, что превышает пару сотен миллисекунд, является вечностью).

Добавьте поле статуса к сообщению. Если вы имеете дело с несколькими терадами напрямую, то вы можете использовать блокировки уровня O / S - чтобы установить флаг.

Почему бы вам не заблокировать всю публикацию, а только ее идентификатор?

Я бы лично выбрал подход Грега или Конрада .

Если вы действительно хотите заблокировать против сам идентификатор поста (и при условии, что ваш код будет когда-либо выполняться только в одном процессе), тогда что-то вроде этого не слишком грязно:

public class ModeratorUtils
{
    private static readonly HashSet<int> _LockedPosts = new HashSet<int>();

    public void ModeratePost(int postId)
    {
        bool lockedByMe = false;
        try
        {
            lock (_LockedPosts)
            {
                lockedByMe = _LockedPosts.Add(postId);
            }

            if (lockedByMe)
            {
                // do your editing
            }
            else
            {
                // sorry, can't edit at this time
            }
        }
        finally
        {
            if (lockedByMe)
            {
                lock (_LockedPosts)
                {
                    _LockedPosts.Remove(postId);
                }
            }
        }
    }
}

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

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

Вы хотите, чтобы удаление не происходило дважды?

CREATE PROCEDURE RemovePost( @postID int )
AS
    if exists(select postID from Posts where postID = @postID)
    BEGIN
        DELETE FROM Posts where postID = @postID
        -- Do other stuff
    END

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

В любом случае, это сработает в большинстве случаев. Единственный раз, когда он потерпит неудачу, это если два модератора отправят запрос почти в одно и то же время, а функция exists () передаст один запрос непосредственно перед тем, как оператор DELETE выполнится для другого запроса. Я бы с радостью использовал это для небольшого сайта. Вы можете сделать еще один шаг и проверить, что удаление действительно удаляет строку, прежде чем продолжить с остальными, что гарантирует атомарность всего этого.

Попытка создать блокировку в коде, для этого варианта использования, я считаю очень непрактично.