Rather than *worry* about locking the entire hashtable badly affecting
performance, *measure* it. You only need to lock for the amount of time
it takes to fetch the entry and update it.

Unless you are processing hundreds of thousands of requests per second,
I doubt it will actually affect performance that badly.

They'd only need to be synchronized while logging that a request happened -
not for the actual duration of the request. In most cases I would imagine
that this won't create a bottleneck (compared to everything else going on),
so until profiling *shows* that you have a problem, I'd use synchronized
access to a dictionary<something, int> where something relates to your user
id.

Something like (off the cuff code):

static class UserCounters
{
   private static readonly Dictionary<string, int> counter =
       new
Dictionary<string,int>(StringComparer.InvariantCultureIgnoreCase);
   public static void LogAccess(string cn)
   {
       lock (counter)
       {
           int value;
           if (counter.TryGetValue(cn, out value))
           {
               counter[cn] = value + 1;
           }
           else
           {
               counter.Add(cn, 1);
           }
       }
   }
   public static KeyValuePair<string, int>[] Dump(bool reset)
   {
       lock (counter)
       {
           KeyValuePair<string, int>[] data = new KeyValuePair<string,
int>[counter.Count];
           int index = 0;
           foreach (KeyValuePair<string, int> pair in counter)
           {
               data[index++] = pair;
           }
           if (reset)
           {
               counter.Clear();
           }
           return data;
       }
   }
}