/// <summary>
/// 一次将对象添加到结尾处(如果已含则不添加)
/// </summary>
/// <param name="item">要添加的对象. 对于引用类型, 该值可以为 null</param>
public bool AddOnce(T item)
{
_rwLock.AcquireReaderLock(Timeout.Infinite);
try
{
if (!_infos.Contains(item))
{
LockCookie lockCookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
DoAdd(item);
return(true);
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
return(false);
}
finally
{
_rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// Gets objects from the database
/// </summary>
/// <returns>List(Specialization)</returns>
public static List<Specialization> GetAll()
{
rwlock.AcquireReaderLock(Timeout.Infinite);
try
{
if (IsOutdated)
{
LockCookie lc = rwlock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (IsOutdated)
SynchronizeContent();
}
finally
{
rwlock.DowngradeFromWriterLock(ref lc);
}
}
List<Specialization> returnedCities = new List<Specialization>();
returnedCities.AddRange(_allSpecialities);
return returnedCities;
}
finally
{
rwlock.ReleaseReaderLock();
}
}
/// <summary>
/// Returns a specific Specialization from the cached collection based on its ID
/// </summary>
/// <param name="id">The Specialization ID object</param>
/// <returns>Specialization</returns>
public static List <DoctorSearchResponseInfo> GetAllDoctors()
{
rwlock.AcquireReaderLock(Timeout.Infinite);
try
{
bool isSynchronized = false;
if (IsOutdated)
{
LockCookie lc = rwlock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (IsOutdated)
{
SynchronizeContent();
isSynchronized = true;
}
}
finally
{
rwlock.DowngradeFromWriterLock(ref lc);
}
}
List <DoctorSearchResponseInfo> doctorSearchResponses = new List <DoctorSearchResponseInfo>();
doctorSearchResponses.AddRange(_allDoctors);
return(doctorSearchResponses);
}
finally
{
rwlock.ReleaseReaderLock();
}
}
/// <summary>
/// Gets objects from the database
/// </summary>
/// <returns>List(Specialization)</returns>
public static List <SearchInputInfo> GetAll()
{
rwlock.AcquireReaderLock(Timeout.Infinite);
try
{
if (IsOutdated)
{
LockCookie lc = rwlock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (IsOutdated)
{
SynchronizeContent();
}
}
finally
{
rwlock.DowngradeFromWriterLock(ref lc);
}
}
List <SearchInputInfo> returnedSearches = new List <SearchInputInfo>();
returnedSearches.AddRange(_allSpearchInputs);
return(returnedSearches);
}
finally
{
rwlock.ReleaseReaderLock();
}
}
Type CreateDynamicClass(DynamicProperty[] properties)
{
LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
string typeName = "DynamicClass" + (classCount + 1);
#if ENABLE_LINQ_PARTIAL_TRUST
new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
try
{
TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class |
TypeAttributes.Public, typeof(object));
FieldInfo[] fields = GenerateProperties(tb, properties);
GenerateEquals(tb, fields);
GenerateGetHashCode(tb, fields);
Type result = tb.CreateType();
return(result);
}
finally
{
#if ENABLE_LINQ_PARTIAL_TRUST
PermissionSet.RevertAssert();
#endif
}
}
finally
{
classCount++;
rwLock.DowngradeFromWriterLock(ref cookie);
}
}
public void DataserverReply(string identifier, string reply)
{
DataserverRequest ds;
DataServerRequestsRwLock.AcquireReaderLock(-1);
try
{
if (!DataserverRequests.ContainsKey(identifier))
{
return;
}
ds = DataserverRequests[identifier];
LockCookie lc = DataServerRequestsRwLock.UpgradeToWriterLock(-1);
try
{
DataserverRequests.Remove(identifier);
}
finally
{
DataServerRequestsRwLock.DowngradeFromWriterLock(ref lc);
}
}
finally
{
DataServerRequestsRwLock.ReleaseReaderLock();
}
m_CmdManager.m_ScriptEngine.PostObjectEvent(ds.localID,
new EventParams("dataserver", new Object[]
{ new LSL_Types.LSLString(ds.ID.ToString()),
new LSL_Types.LSLString(reply) },
new DetectParams[0]));
}
public void Join(Player player, Coords system)
{
rwl.AcquireReaderLock(-1);
string systemId = system.ToString();
try {
if (!Systems.ContainsKey(systemId))
{
var lc = rwl.UpgradeToWriterLock(-1);
try {
if (!Systems.ContainsKey(systemId))
{
Console.WriteLine("Creating System Area {0}", systemId);
StarSystemAreaManager_Entry obj = new StarSystemAreaManager_Entry(system);
Systems.Add(systemId, obj);
obj.Join(player);
CreateNPCs(obj);
}
} finally {
rwl.DowngradeFromWriterLock(ref lc);
}
}
else
{
Systems[systemId].Join(player);
}
} finally {
rwl.ReleaseReaderLock();
}
}
/// <summary>
/// 对象级别线程安全写操作，有返回
/// </summary>
/// <param name="ac"></param>
/// <returns></returns>
public T threadSafeExecuteReturnValue <T>(Func <T> ac)
{
if (_RWLockObject.IsReaderLockHeld)
{
LockCookie lc = _RWLockObject.UpgradeToWriterLock(-1);
try
{
return(ac());
}
finally
{
_RWLockObject.DowngradeFromWriterLock(ref lc);
}
}
else if (!_RWLockObject.IsWriterLockHeld)
{
_RWLockObject.AcquireWriterLock(-1);
try
{
return(ac());
}
finally
{
_RWLockObject.ReleaseWriterLock();
}
}
else
{
return(ac());
}
}
private void TrimValidValue()
{
if (IsCached)
{
List <TKey> invalids = new List <TKey>();
foreach (KeyValuePair <TKey, TValue> kvp in _infos)
{
if (((ICachedObject)kvp.Value).IsInvalid)
{
invalids.Add(kvp.Key);
}
}
if (invalids.Count > 0)
{
LockCookie lockCookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
foreach (TKey item in invalids)
{
_infos.Remove(item);
}
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
}
// <doc>
// <desc>
// Sets the root node given a string
// </desc>
// </doc>
//
private MTNameTableNode AddRoot(ref MTNameTableName name, bool fLock)
{
MTNameTableNode newNode = null;
if (fLock)
{
LockCookie lc = rwLock.UpgradeToWriterLock(timeout);
// recheck for failsafe against race-condition
if (rootNode == null)
{
rootNode = newNode = new MTNameTableNode(ref name);
}
else
{
// try again, with write-lock active
newNode = Add(ref name, false);
}
rwLock.DowngradeFromWriterLock(ref lc);
}
else
{
rootNode = newNode = new MTNameTableNode(ref name);
}
return(newNode);
}
public Bitmap GetBitmap(IconSize size, IntPtr ptr, bool isDirectory, bool forceLoad)
{
Bitmap retVal = null;
sysImgListLock.AcquireReaderLock(1000);
try
{
if (size != sysImgList.CurrentImageListSize)
{
LockCookie lockCookie = sysImgListLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
SystemImageList imgList = sysImgList[size];
retVal = imgList[ptr, isDirectory, forceLoad];
}
finally
{
sysImgListLock.DowngradeFromWriterLock(ref lockCookie);
}
}
else
{
retVal = sysImgList[size][ptr, isDirectory, forceLoad];
}
}
finally { sysImgListLock.ReleaseReaderLock(); }
return(retVal);
}
public void DowngradeTest()
{
LockCookie lc1, lc2, lc3, lc4;
rwlock = new ReaderWriterLock();
rwlock.AcquireReaderLock(Timeout.Infinite);
lc1 = rwlock.UpgradeToWriterLock(Timeout.Infinite);
rwlock.AcquireReaderLock(Timeout.Infinite);
lc2 = rwlock.UpgradeToWriterLock(Timeout.Infinite);
rwlock.AcquireReaderLock(Timeout.Infinite);
lc3 = rwlock.UpgradeToWriterLock(Timeout.Infinite);
rwlock.AcquireReaderLock(Timeout.Infinite);
lc4 = rwlock.UpgradeToWriterLock(Timeout.Infinite);
rwlock.DowngradeFromWriterLock(ref lc2);
Assert.IsFalse(rwlock.IsReaderLockHeld, "A1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "A2");
rwlock.ReleaseReaderLock();
Assert.IsFalse(rwlock.IsReaderLockHeld, "B1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "B2");
rwlock.DowngradeFromWriterLock(ref lc4);
Assert.IsFalse(rwlock.IsReaderLockHeld, "C1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "C2");
rwlock.ReleaseReaderLock();
Assert.IsFalse(rwlock.IsReaderLockHeld, "D1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "D2");
rwlock.DowngradeFromWriterLock(ref lc3);
Assert.IsFalse(rwlock.IsReaderLockHeld, "E1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "E2");
rwlock.ReleaseReaderLock();
Assert.IsFalse(rwlock.IsReaderLockHeld, "F1");
Assert.IsTrue(rwlock.IsWriterLockHeld, "F2");
rwlock.DowngradeFromWriterLock(ref lc1);
Assert.IsTrue(rwlock.IsReaderLockHeld, "G1");
Assert.IsFalse(rwlock.IsWriterLockHeld, "G2");
rwlock.ReleaseReaderLock();
Assert.IsFalse(rwlock.IsReaderLockHeld, "H1");
Assert.IsFalse(rwlock.IsWriterLockHeld, "H2");
}
/// <summary>
/// Get Wcf client instance.
/// </summary>
/// <typeparam name="TTypeBuilder">The proxy class builder.</typeparam>
/// <param name="caching">Caching dictionary to use.</param>
/// <param name="fromCaching">Whether get instance from caching or not.</param>
/// <returns>Instance of a ClientBase derived class.</returns>
private static TChannel GetInstance <TTypeBuilder>(Dictionary <string, TChannel> caching, bool fromCaching = true) where TTypeBuilder : IWcfClientTypeBuilder, new()
{
if (fromCaching)
{
string key = string.Format(WcfClientProxyDictionaryKeyStringFormat, string.Empty, string.Empty);
Lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (caching.ContainsKey(key))
{
return(caching[key]);
}
else
{
LockCookie lockCookie = Lock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (caching.ContainsKey(key))
{
return(caching[key]);
}
else
{
Type type = WcfClientType.BuildType <TChannel, TTypeBuilder>();
TChannel result = (TChannel)Activator.CreateInstance(type);
caching.Add(key, result);
return(result);
}
}
finally
{
Lock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
Lock.ReleaseReaderLock();
}
}
else
{
Type type = WcfClientType.BuildType <TChannel, TTypeBuilder>();
return((TChannel)Activator.CreateInstance(type));
}
}
protected override void ClearItems()
{
if (_dispatcher.CheckAccess())
{
LockCookie c = _lock.UpgradeToWriterLock(-1);
base.ClearItems();
_lock.DowngradeFromWriterLock(ref c);
}
else
{
_dispatcher.Invoke(DispatcherPriority.Background, (SendOrPostCallback) delegate { Clear(); }, null);
}
}
private void Upgrade(Action <T> action)
{
var cookie = Lock.UpgradeToWriterLock(Timeout);
try
{
action(Value);
}
finally
{
Lock.DowngradeFromWriterLock(ref cookie);
}
}
public static TChannel CreateChannel(bool fromCaching = true)
{
if (fromCaching)
{
string key = string.Format(ChannelFactoryDictionaryKeyStringFormat, string.Empty, string.Empty);
Lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (ChannelFactoryDictionary.ContainsKey(key))
{
return(ChannelFactoryDictionary[key].CreateChannel());
}
else
{
LockCookie lockCookie = Lock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (ChannelFactoryDictionary.ContainsKey(key))
{
return(ChannelFactoryDictionary[key].CreateChannel());
}
else
{
ChannelFactory <TChannel> result = new ChannelFactory <TChannel>();
ChannelFactoryDictionary.Add(key, result);
return(result.CreateChannel());
}
}
finally
{
Lock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
Lock.ReleaseReaderLock();
}
}
else
{
return(new ChannelFactory <TChannel>().CreateChannel());
}
}
/// <summary>
/// Opens the log file for the current application.
/// </summary>
/// <param name="logFile">Log file for the current application; if null or string.Empty use the default log file.</param>
/// <returns>Logger instance.</returns>
public static Logger Open(string logFile = null)
{
LogConfig logConfig = new LogConfig();
if (!string.IsNullOrEmpty(logFile))
{
logConfig.LogFile = logFile;
}
int key = logConfig.GetHashCode();
Lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (LoggerDictionary.ContainsKey(key))
{
return(LoggerDictionary[key]);
}
else
{
LockCookie lockCookie = Lock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (LoggerDictionary.ContainsKey(key))
{
return(LoggerDictionary[key]);
}
else
{
Logger result = new Logger(logConfig);
LoggerDictionary.Add(key, result);
return(result);
}
}
finally
{
Lock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
Lock.ReleaseReaderLock();
}
}
/// <summary>
/// 保存对象日志
/// </summary>
/// <param name="info">事件资料</param>
/// <returns>返回对象</returns>
public static bool Save(EventInfo info)
{
_rwLock.AcquireReaderLock(Timeout.Infinite);
try
{
bool differed = String.CompareOrdinal(_differedMessage, info.Message) != 0;
if (!differed && _messageRepetitions >= BreakThresholdOfRepeatPerMinute &&
_messageRepetitions / DateTime.Now.Subtract(_differedDateTime).TotalMinutes >= BreakThresholdOfRepeatPerMinute)
{
return(true);
}
bool result = Database.ExecuteGet(Save, info);
if (!differed)
{
LockCookie lockCookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
_messageRepetitions = _messageRepetitions + 1;
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
else if (_messageRepetitions != 0)
{
LockCookie lockCookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
_messageRepetitions = 0;
_differedDateTime = DateTime.Now;
_differedMessage = info.Message;
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
return(result);
}
finally
{
_rwLock.ReleaseReaderLock();
}
}
private const int MAX_LOCK_WAIT = 5000; // milliseconds
protected T WriterLockOperations <T>(Func <T> func)
{
bool LockUpgraded = readWriteLock.IsReaderLockHeld;
LockCookie lc = new LockCookie();
if (LockUpgraded)
{
lc = readWriteLock.UpgradeToWriterLock(MAX_LOCK_WAIT);
}
else
{
readWriteLock.AcquireWriterLock(MAX_LOCK_WAIT);
}
try
{
return(func());
}
finally
{
//lock durumunu eski haline getir.
if (LockUpgraded)
{
readWriteLock.DowngradeFromWriterLock(ref lc);
}
else
{
readWriteLock.ReleaseWriterLock();
}
}
}
/// <summary>
/// The relative thread ID, starting at zero.
/// </summary>
private static int GetThreadID()
{
_threadIDsLock.AcquireReaderLock(-1);
try
{
int id = 0;
if (!_threadIDs.TryGetValue(Thread.CurrentThread.ManagedThreadId, out id))
{
LockCookie cookie = _threadIDsLock.UpgradeToWriterLock(-1);
id = _threadIDs.Count;
try
{
_threadIDs[Thread.CurrentThread.ManagedThreadId] = id;
}
finally
{
_threadIDsLock.DowngradeFromWriterLock(ref cookie);
}
}
return(id);
}
finally
{
_threadIDsLock.ReleaseReaderLock();
}
}
public void DowngradeFromWriterLock(TestLockCookie tlc, int expectedFailureHResult = 0)
{
Assert.NotNull(tlc);
PerformLockAction(
expectedFailureHResult,
false /* isBlockingOperation */,
() => _rwl.DowngradeFromWriterLock(ref tlc._lockCookie),
() =>
{
Assert.Equal(Environment.CurrentManagedThreadId, _writerThreadID);
Assert.NotEqual(0, _writerLevel);
if (tlc._readerLevel == 0)
{
Assert.True(_writerLevel > tlc._writerLevel);
_writerLevel = tlc._writerLevel;
if (_writerLevel == 0)
{
_writerThreadID = InvalidThreadID;
}
}
else
{
_writerLevel = 0;
_writerThreadID = InvalidThreadID;
Assert.True(ThreadReaderLevel == 0);
ThreadReaderLevel = tlc._readerLevel;
}
});
}
Type CreateDynamicClass(DynamicProperty[] properties, String ClassName = null)
{
LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
string typeName = !String.IsNullOrEmpty(ClassName) ? ClassName : "DynamicClass" + (classCount + 1);
try
{
TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class |
TypeAttributes.Public, typeof(DynamicClass));
FieldInfo[] fields = GenerateProperties(tb, properties);
GenerateEquals(tb, fields);
GenerateGetHashCode(tb, fields);
#if NETSTANDARD2_0
Type result = tb.CreateTypeInfo();
#elif NET461
Type result = tb.CreateType();
#endif
classCount++;
return(result);
}
finally
{
}
}
finally
{
rwLock.DowngradeFromWriterLock(ref cookie);
}
}
/// <summary>
/// Execute the action under a write lock
/// </summary>
/// <param name="cacheAction">The cache action.</param>
public void WriteLock(CacheAction cacheAction)
{
if (readerWriterLock.IsWriterLockHeld)
{
cacheAction();
return;
}
bool readerLockHeld = readerWriterLock.IsReaderLockHeld;
LockCookie writerLock = new LockCookie();
if (readerLockHeld)
{
writerLock = readerWriterLock.UpgradeToWriterLock(Timeout.Infinite);
}
else
{
readerWriterLock.AcquireWriterLock(Timeout.Infinite);
}
try
{
cacheAction();
}
finally
{
if (readerLockHeld)
{
readerWriterLock.DowngradeFromWriterLock(ref writerLock);
}
else
{
readerWriterLock.ReleaseWriterLock();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="properties"></param>
/// <param name="methods"></param>
/// <returns></returns>
private Type CreateDynamicClass(DynamicProperty[] properties, DynamicMethod[] methods)
{
var cookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
var typeName = _typeName;
try
{
_typeBuilder = _moduleBuilder.DefineType(typeName, TypeAttributes.Class |
TypeAttributes.Public, typeof(DynamicClass));
CreateConstructor(_typeBuilder);
var fields = GenerateProperties(_typeBuilder, properties);
GenerateEquals(_typeBuilder, fields);
GenerateGetHashCode(_typeBuilder, fields);
if (methods != null)
{
GenerateMethods(_typeBuilder, methods);
}
// Create the type, return the type.
var result = _typeBuilder.CreateType();
return(result);
}
finally { }
}
finally
{
_rwLock.DowngradeFromWriterLock(ref cookie);
}
}
public void AddBlock(IBlock block)
{
var hash = block.BlockHashToHex;
_logger?.Trace($"Added block {hash} to block cache.");
_rwLock.AcquireReaderLock(Timeout);
try
{
if (_blockCache.Any(b => b.BlockHashToHex == block.BlockHashToHex))
{
return;
}
var lc = _rwLock.UpgradeToWriterLock(Timeout);
try
{
_blockCache.Add(block.Clone());
_blockCache = _blockCache.OrderBy(b => b.Index).ToList();
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lc);
}
}
finally
{
_rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// 将集合的元素复制到新数组中
/// <param name="clearSource">并清空源</param>
/// </summary>
public T[] ToArray(bool clearSource = false)
{
_rwLock.AcquireReaderLock(Timeout.Infinite);
try
{
T[] result = _infos.ToArray();
if (clearSource)
{
LockCookie lockCookie = _rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
_infos.Clear();
}
finally
{
_rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
return(result);
}
finally
{
_rwLock.ReleaseReaderLock();
}
}
protected TValue GetOrCreate(TKey key, Func <TValue> creator)
{
TValue value;
try
{
_lock.AcquireReaderLock(-1);
if (_cache.TryGetValue(key, out value))
{
return(value);
}
LockCookie cookie = _lock.UpgradeToWriterLock(-1);
try
{
value = creator();
_cache[key] = value;
}
finally
{
_lock.DowngradeFromWriterLock(ref cookie);
}
}
finally
{
_lock.ReleaseReaderLock();
}
return(value);
}
public static TResult GetWriteLock <TResult>(ReaderWriterLock lockObj, int timeout, DoWorkFunc <TResult> doWork)
{
var status = (lockObj.IsWriterLockHeld ? RWLockStatus.WriteLock : (lockObj.IsReaderLockHeld ? RWLockStatus.ReadLock : RWLockStatus.Unlocked));
var writeLock = default(LockCookie);
if (status == RWLockStatus.ReadLock)
{
writeLock = lockObj.UpgradeToWriterLock(timeout);
}
else if (status == RWLockStatus.Unlocked)
{
lockObj.AcquireWriterLock(timeout);
}
try
{
return(doWork());
}
finally
{
if (status == RWLockStatus.ReadLock)
{
lockObj.DowngradeFromWriterLock(ref writeLock);
}
else if (status == RWLockStatus.Unlocked)
{
lockObj.ReleaseWriterLock();
}
}
}
private Type CreateDynamicClass(string typeName, DynamicProperty[] properties)
{
var cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
typeName = string.IsNullOrEmpty(typeName) ? "DynamicClass" + (classCount + 1) : typeName;
#if ENABLE_LINQ_PARTIAL_TRUST
new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
try
{
var tb = this.module
.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public, typeof(DynamicClass));
var fields = GenerateProperties(tb, properties);
GenerateEquals(tb, fields);
GenerateGetHashCode(tb, fields);
var result = tb.CreateTypeInfo();
classCount++;
return(result);
}
finally
{
#if ENABLE_LINQ_PARTIAL_TRUST
PermissionSet.RevertAssert();
#endif
}
}
finally
{
rwLock.DowngradeFromWriterLock(ref cookie);
}
}
public void AddUser(UUID uuid, string first, string last)
{
m_UserCacheRwLock.AcquireReaderLock(-1);
try
{
if (m_UserCache.ContainsKey(uuid))
{
return;
}
UserData user = new UserData();
user.Id = uuid;
user.FirstName = first;
user.LastName = last;
LockCookie lc = m_UserCacheRwLock.UpgradeToWriterLock(-1);
try
{
m_UserCache[user.Id] = user;
}
finally
{
m_UserCacheRwLock.DowngradeFromWriterLock(ref lc);
}
}
finally
{
m_UserCacheRwLock.ReleaseReaderLock();
}
}
