(精华)2020年6月27日 C#类库 读写锁帮助类

using System;
using System.Threading;

namespace Core.Util
{
    /// 

    /// 使用using代替lock操作的对象,可指定写入和读取锁定模式
    /// 参考:https://www.cnblogs.com/blqw/p/3475734.html
    /// 
    /// 
    public class UsingLock<T> : IDisposable
    {
        #region 内部类

        /// 
 利用IDisposable的using语法糖方便的释放锁定操作
        /// 内部类
        /// 
        private struct Lock : IDisposable
        {
            /// 
 读写锁对象
            /// 
            private ReaderWriterLockSlim _Lock;
            /// 
 是否为写入模式
            /// 
            private bool _IsWrite;
            /// 
 利用IDisposable的using语法糖方便的释放锁定操作
            /// 构造函数
            /// 
            /// 读写锁
            /// 写入模式为true,读取模式为false
            public Lock(ReaderWriterLockSlim rwl, bool isWrite)
            {
                _Lock = rwl;
                _IsWrite = isWrite;
            }
            /// 
 释放对象时退出指定锁定模式
            /// 
            public void Dispose()
            {
                if (_IsWrite)
                {
                    if (_Lock.IsWriteLockHeld)
                    {
                        _Lock.ExitWriteLock();
                    }
                }
                else
                {
                    if (_Lock.IsReadLockHeld)
                    {
                        _Lock.ExitReadLock();
                    }
                }
            }
        }

        /// 
 空的可释放对象,免去了调用时需要判断是否为null的问题
        /// 内部类
        /// 
        private class Disposable : IDisposable
        {
            /// 
 空的可释放对象
            /// 
            public static readonly Disposable Empty = new Disposable();
            /// 
 空的释放方法
            /// 
            public void Dispose() { }
        }

        #endregion

        /// 
 读写锁
        /// 
        private ReaderWriterLockSlim _LockSlim = new ReaderWriterLockSlim();

        /// 
 保存数据
        /// 
        private T _Data;

        /// 
 使用using代替lock操作的对象,可指定写入和读取锁定模式
        /// 构造函数
        /// 
        public UsingLock()
        {
            Enabled = true;
        }

        public UsingLock(T data)
        {
            Enabled = true;
            _Data = data;
        }

        /// 
 获取或设置当前对象中保存数据的值
        /// 
        /// 获取数据时未进入读取或写入锁定模式
        /// 设置数据时未进入写入锁定模式
        public T Data
        {
            get
            {
                if (_LockSlim.IsReadLockHeld || _LockSlim.IsWriteLockHeld)
                {
                    return _Data;
                }
                throw new MemberAccessException("请先进入读取或写入锁定模式再进行操作");
            }
            set
            {
                if (_LockSlim.IsWriteLockHeld == false)
                {
                    throw new MemberAccessException("只有写入模式中才能改变Data的值");
                }
                _Data = value;
            }
        }

        /// 
 是否启用,当该值为false时,Read()和Write()方法将返回 Disposable.Empty
        /// 
        public bool Enabled { get; set; }

        /// 
 进入读取锁定模式,该模式下允许多个读操作同时进行
        /// 退出读锁请将返回对象释放,建议使用using语块
        /// Enabled为false时,返回Disposable.Empty;
        /// 在读取或写入锁定模式下重复执行,返回Disposable.Empty;
        /// 
        public IDisposable Read()
        {
            if (Enabled == false || _LockSlim.IsReadLockHeld || _LockSlim.IsWriteLockHeld)
            {
                return Disposable.Empty;
            }
            else
            {
                _LockSlim.EnterReadLock();
                return new Lock(_LockSlim, false);
            }
        }

        /// 
 进入写入锁定模式,该模式下只允许同时执行一个读操作
        /// 退出读锁请将返回对象释放,建议使用using语块
        /// Enabled为false时,返回Disposable.Empty;
        /// 在写入锁定模式下重复执行,返回Disposable.Empty;
        /// 
        /// 读取模式下不能进入写入锁定状态
        public IDisposable Write()
        {
            if (Enabled == false || _LockSlim.IsWriteLockHeld)
            {
                return Disposable.Empty;
            }
            else if (_LockSlim.IsReadLockHeld)
            {
                throw new NotImplementedException("读取模式下不能进入写入锁定状态");
            }
            else
            {
                _LockSlim.EnterWriteLock();
                return new Lock(_LockSlim, true);
            }
        }

        public void Dispose()
        {
            _LockSlim.Dispose();
        }
    }
}