Est-il possible d'utiliser une chaîne comme un verrouillage de l'objet?

Je dirais que c'est une très mauvaise idée, personnellement. Ce n'est pas ce que les chaînes sont pour.

(Personnellement je n'aime pas le fait que chaque objet a un moniteur en premier lieu, mais c'est un peu une autre préoccupation.)

Si vous souhaitez un objet qui représente un verrou qui peut être partagé entre les différentes instances, pourquoi ne pas créer un type spécifique pour cela? Vous pouvez donné le verrouillage d'un nom assez facilement pour des fins de diagnostic, mais le verrouillage est vraiment pas le but d'une chaîne. Quelque chose comme ceci:

public sealed class Lock
{
    private readonly string name;

    public string Name { get { return name; } }

    public Lock(string name)
    {
        if (name == null)
        {
            throw new ArgumentNullException("name");
        }
        this.name = name;
    }
}

Compte tenu de la façon dont les chaînes sont parfois internés et parfois pas (dans un sens qui peut parfois être difficiles à discerner, par simple inspection), vous pourriez facilement vous retrouver avec accidentellement verrous partagés où vous n'avez pas l'intention d'eux.

J'ai eu un problème similaire il n'ya pas longtemps, où j'ai été la recherche d'un bon moyen de verrouiller une section de code basé sur une chaîne de valeur. Voici ce que nous avons en place à l'heure actuelle, qui résout le problème de l'internement des cordes et a la granularité nous voulons.

L'idée principale est de maintenir un statique ConcurrentDictionary de synchronisation des objets avec une chaîne de clé. Lorsqu'un thread entre dans la méthode, il établit immédiatement une serrure et les tentatives d'ajout de la synchronisation de l'objet de la simultanées dictionnaire. Si nous pouvons ajouter à la simultanées dictionnaire, cela signifie qu'aucun autre thread avoir un verrou basé sur notre chaîne de clé et nous pouvons continuer notre travail. Sinon, nous allons utiliser la synchronisation de l'objet de la simultanées dictionnaire d'établir un deuxième verrou, qui va attendre que le thread en cours d'exécution à la fin du traitement. Lorsque le second verrou est libéré, nous pouvons tenter d'ajouter le thread en cours de synchronisation de l'objet dans le dictionnaire de nouveau.

Un mot de prudence: les fils ne sont pas mis en file d'attente - si plusieurs threads avec les mêmes clés de la chaîne sont en concurrence simultanément pour une serrure, il n'y a aucune garantie quant à l'ordre dans lequel ils seront traités.

Hésitez pas à critiquer si vous pensez que j'ai oublié quelque chose.

public class Foo
{
    private static ConcurrentDictionary<string, object> _lockDictionary = new ConcurrentDictionary<string, object>();

    public void DoSomethingThreadCriticalByString(string lockString)
    {
        object thisThreadSyncObject = new object();

        lock (thisThreadSyncObject)
        {
            try
            {
                for (; ; )
                {
                   object runningThreadSyncObject = _lockDictionary.GetOrAdd(lockString, thisThreadSyncObject);
                   if (runningThreadSyncObject == thisThreadSyncObject)
                       break;

                    lock (runningThreadSyncObject)
                    {
                        //Wait for the currently processing thread to finish and try inserting into the dictionary again.
                    }
                }

                //Do your work here.

            }
            finally
            {
                //Remove the key from the lock dictionary
                object dummy;
                _lockDictionary.TryRemove(lockString, out dummy);
            }
        }
    }
}