浅谈C#在网络波动时防重复提交的方法

public class Cache
  {
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly Dictionary _map = new Dictionary();

    public int Count {
      get { return _map.Count; }
    }

    public TValue Execute(TKey key, Func factory)
    {
      // Check cache
      _lock.EnterReadLock();
      TValue val;
      try {
        if (_map.TryGetValue(key, out val))
          return val;
      } finally {
        _lock.ExitReadLock();
      }

      // Cache it
      _lock.EnterWriteLock();
      try {
        // Check again
        if (_map.TryGetValue(key, out val))
          return val;

        // Create it
        val = factory();

        // Store it
        _map.Add(key, val);

        // Done
        return val;
      } finally {
        _lock.ExitWriteLock();
      }
    }

    public void Clear()
    {
      // Cache it
      _lock.EnterWriteLock();
      try {
        _map.Clear();
      } finally {
        _lock.ExitWriteLock();
      }
    }
  }

/// 

  /// 防重复缓存
  /// 
  /// 
  /// 
  public class AntiDupCache
  {
    private readonly int _maxCount;//缓存最高数量
    private readonly long _expireTicks;//超时 Ticks
    private long _lastTicks;//最后Ticks
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly ReaderWriterLockSlim _slimLock = new ReaderWriterLockSlim();
    private readonly Dictionary> _map = new Dictionary>();
    private readonly Dictionary _lockDict = new Dictionary();
    private readonly Queue _queue = new Queue();
    class AntiDupLockSlim : ReaderWriterLockSlim { public int UseCount; }

    /// 

    /// 防重复缓存
    /// 
    /// 缓存最高数量,0 不缓存，-1 缓存所有
    /// 超时秒数,0 不缓存，-1 永久缓存 
    public AntiDupCache(int maxCount = 100, int expireSecond = 1)
    {
      if (maxCount < 0) {
        _maxCount = -1;
      } else {
        _maxCount = maxCount;
      }
      if (expireSecond < 0) {
        _expireTicks = -1;
      } else {
        _expireTicks = expireSecond * TimeSpan.FromSeconds(1).Ticks;
      }
    }

    /// 

    /// 个数
    /// 
    public int Count {
      get { return _map.Count; }
    }

    /// 

    /// 执行
    /// 
    /// 值
    /// 执行方法
    /// 
    public TValue Execute(TKey key, Func factory)
    {
      // 过期时间为0 则不缓存
      if (object.Equals(null, key) || _expireTicks == 0L || _maxCount == 0) { return factory(); }

      Tuple tuple;
      long lastTicks;
      _lock.EnterReadLock();
      try {
        if (_map.TryGetValue(key, out tuple)) {
          if (_expireTicks == -1) return tuple.Item2;
          if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
        }
        lastTicks = _lastTicks;
      } finally { _lock.ExitReadLock(); }


      AntiDupLockSlim slim;
      _slimLock.EnterUpgradeableReadLock();
      try {
        _lock.EnterReadLock();
        try {
          if (_lastTicks != lastTicks) {
            if (_map.TryGetValue(key, out tuple)) {
              if (_expireTicks == -1) return tuple.Item2;
              if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
            }
            lastTicks = _lastTicks;
          }
        } finally { _lock.ExitReadLock(); }

        _slimLock.EnterWriteLock();
        try {
          if (_lockDict.TryGetValue(key, out slim) == false) {
            slim = new AntiDupLockSlim();
            _lockDict[key] = slim;
          }
          slim.UseCount++;
        } finally { _slimLock.ExitWriteLock(); }
      } finally { _slimLock.ExitUpgradeableReadLock(); }


      slim.EnterWriteLock();
      try {
        _lock.EnterReadLock();
        try {
          if (_lastTicks != lastTicks && _map.TryGetValue(key, out tuple)) {
            if (_expireTicks == -1) return tuple.Item2;
            if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
          }
        } finally { _lock.ExitReadLock(); }

        var val = factory();
        _lock.EnterWriteLock();
        try {
          _lastTicks = DateTime.Now.Ticks;
          _map[key] = Tuple.Create(_lastTicks, val);
          if (_maxCount > 0) {
            if (_queue.Contains(key) == false) {
              _queue.Enqueue(key);
              if (_queue.Count > _maxCount) _map.Remove(_queue.Dequeue());
            }
          }
        } finally { _lock.ExitWriteLock(); }
        return val;
      } finally {
        slim.ExitWriteLock();
        _slimLock.EnterWriteLock();
        try {
          slim.UseCount--;
          if (slim.UseCount == 0) {
            _lockDict.Remove(key);
            slim.Dispose();
          }
        } finally { _slimLock.ExitWriteLock(); }
      }
    }
    /// 

    /// 清空
    /// 
    public void Clear()
    {
      _lock.EnterWriteLock();
      try {
        _map.Clear();
        _queue.Clear();
        _slimLock.EnterWriteLock();
        try {
          _lockDict.Clear();
        } finally {
          _slimLock.ExitWriteLock();
        }
      } finally {
        _lock.ExitWriteLock();
      }
    }

  }

private readonly static AntiDupCache antiDupCache = new AntiDupCache(50, 1);

  antiDupCache.Execute(key, () => {

     ....

     return val;

  });