public static void DoSomething( int ID )
{
   /// Здесь асинхронный вызов некой хранимки с передачей ей ID,
}

public static void DoSomethingFinished( .. )
{
  /// Здесь получаем результаты асинхронного запроса
}

private static Dictionary<int, bool> m_InProc;

public static void DoSomething( int ID )
{
   if ( m_InProc.ContainKey( ID ) )
   {
      if ( m_InProc[ID] )
         return;
   }

   m_InProc[ID] = true;
   /// Здесь асинхронный вызов некой хранимки с передачей ей ID,
}

public static void DoSomethingFinished( .. )
{
  /// Здесь получаем результаты асинхронного запроса
  m_InProc[ID] = false;
}

lock( myDictionary )
{
  /// работа с  myDictionary.
}

А>lock( myDictionary )
А>{
А>  /// работа с  myDictionary.
А>}

А>

lock(var_1){
lock(var_2){
    //здесь потокобезопасный 
    //доступ к var_1 и var_2
  }
}

A Dictionary(Of TKey, TValue) can support multiple readers concurrently, as long as the collection is not modified. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

In general, avoid locking on a public type, or instances beyond your code's control.
…
Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.

Strictly speaking, the object provided is used solely to uniquely identify the resource being shared among multiple threads, so it can be an arbitrary class instance. In practice, however, this object usually represents the resource for which thread synchronization is necessary. For example, if a container object is to be used by multiple threads, then the container can be passed to lock, and the synchronized code block following the lock would access the container. As long as other threads locks on the same contain before accessing it, then access to the object is safely synchronized.

private class DictItem<T>
{
    private int _locked;
    public bool Acquire(){return 0 == Interlocked.Exchenge(ref _locked, 1);}
    public void Release(){Interlocked.Exchenge(ref _locked, 0);}
    public T Item;
}

_FR>>In general, avoid locking on a public type, or instances beyond your code's control.
_FR>>…
_FR>>Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.

K>Соответственно не рекомендуют лочиться в библиотеках именно потому, что вызывающий код может (и будет) лочиться на них. Не зря же упомянули только публичные типы

        readonly HashSet<long> InProgress = new HashSet<long>();
        readonly object InProgressSync = new object();

bool SetInProgress(long id)
        {
            lock (InProgressSync)
            {
                if (InProgress.Contains(id))
                    return false;

                InProgress.Add(id);
                return true;
            }
        }