Queuing web service calls Every call to the web service goes through a custom queuing system. This has a limit that is set to 1. Every call that enters the same time with another call is purged and not handled. Not sure if this is completely thread safe.

public void QueueForExecution(T value)
{
    lock (_queueLock)
    {
        if (_entryCount &lt; _queueLimit)
        {
            Interlocked.Increment(ref _entryCount);
            Logger.Trace(String.Format("Running task queue item for {0}.", _methodName));

            Task.Run(() =&gt; RunTask(value));
        }
        else
        {
            lock (_queueItemLock)
            {
                _queuedExecutionValue = value;
            }
            Logger.Trace(String.Format("Task queue limit reached for {0} - queued request - overriding any previous queued items.", _methodName));
        }
    }
}
If any locking on _queueItemLock is happening inside a lock on _queueLock then you can consider this as thread safe.  

If any access of _entryCount is done in a lock on _queueLock then you don't need the Interlocked.Increment(ref _entryCount); but you can just increment in the normal way.  

If you by any chance are using C# 6.0 (VS 2015) you can use string interpolation by using the $ operator without the need of calling string.Format() like so  

Logger.Trace($"Running task queue item for {_methodName}.");  


other than that there isn't much to say.