public bool AddWrappedItem(object o, bool allowLinking = true) { if (o is T cast) { if (!_contains.Contains(cast)) { WriterLock wl = null; var wasEnableLinked = EnableLinking; try { if (!allowLinking && EnableLinking) { wl = new WriterLock(_lock); EnableLinking = false; } this.Add(cast); } finally { if (wl != null) { EnableLinking = wasEnableLinked; wl.Dispose(); } } return(true); } } return(false); }
public IDisposable Write() { var locker = new WriterLock(this); lock (_lockers) _lockers.Add(locker); return(locker); }
public void ClearListeners() { using (WriterLock wl = new WriterLock(listenerRWLock)) { listenerEndPoints.Clear(); doSendDataValues = false; } }
public void RemoveListener(IPEndPoint ep) { // acquire a write lock using (WriterLock wl = new WriterLock(listenerRWLock)) { // add the end point if it doesn't exists already listenerEndPoints.Remove(ep); doSendDataValues = listenerEndPoints.Count > 0; } }
public void RegisterListener(IPEndPoint ep) { // acquire a write lock using (WriterLock wl = new WriterLock(listenerRWLock)) { // add the end point if it doesn't exists already if (!listenerEndPoints.Contains(ep)) { listenerEndPoints.Add(ep); } // indicate that we're now sending value doSendDataValues = true; } }
public void WriterTimedOutIsSetIfTimeoutTimespan() { ReaderWriterLock rwLock = new ReaderWriterLock(); Thread t = new Thread(new ParameterizedThreadStart(AcquireReaderLock)); t.Start(rwLock); Thread.Sleep(20); using (WriterLock l = new WriterLock(rwLock, TimeSpan.FromMilliseconds(10))) { Assert.IsTrue(l.TimedOut); } Assert.IsFalse(rwLock.IsWriterLockHeld); }
public static void Animate(Gdi::Image image, System.EventHandler onFrameChangedHandler) { if (image == null) { return; } ImageInfo item = null; lock (image) item = new ImageInfo(image); StopAnimate(image, onFrameChangedHandler); WriterLock w_lock; using (new WriterLockWait()) w_lock = new WriterLock(rwImgListLock); using (w_lock){ if (!item.animated) { return; } if (imageInfoList == null) { imageInfoList = new Gen::List <ImageInfo>(); } item.onFrameChangedHandler = onFrameChangedHandler; imageInfoList.Add(item); if (animationThread == null) { animationThread = new Thr::Thread(new Thr::ThreadStart(ImageAnimator.AnimateImages50ms)); animationThread.Name = typeof(ImageAnimator).Name; animationThread.IsBackground = true; animationThread.Start(); } } }
public static void StopAnimate(Gdi::Image image, System.EventHandler onFrameChangedHandler) { if (image == null || imageInfoList == null) { return; } WriterLock w_lock; using (new WriterLockWait()) w_lock = new WriterLock(rwImgListLock); using (w_lock){ ImageInfo item = imageInfoList.Find(delegate(ImageInfo info){ return(image == info.Image); }); if (item == null) { return; } if (onFrameChangedHandler == item.onFrameChangedHandler || onFrameChangedHandler != null && onFrameChangedHandler.Equals(item.onFrameChangedHandler)) { imageInfoList.Remove(item); } } }
public virtual bool SetValue(string propName, object value, Type preferredType = null, bool isRequired = false) { using (var wl = new WriterLock(_lock)) { if (preferredType != null) { if (preferredType.IsValueType && !isRequired && !(preferredType.IsGenericType && preferredType.GetGenericTypeDefinition() == typeof(Nullable <>))) { preferredType = typeof(Nullable <>).MakeGenericType(preferredType); } _preferredType[propName] = preferredType; } if (_preferredType.TryGetValue(propName, out Type pt)) { try { bool isnull = pt.IsGenericType && pt.GetGenericTypeDefinition() == typeof(Nullable <>); if (value != null) { if (value.GetType() != pt && (!isnull || value.GetType() != Nullable.GetUnderlyingType(pt))) { if (value is IConvertible) { if (isnull) { value = InternalChangeType(value, Nullable.GetUnderlyingType(pt)); } else { value = InternalChangeType(value, pt); } } else { throw new InvalidCastException("Cannot coerce type."); } } } else { if (isnull) { value = pt.FastCreateNoParm(); } } } catch { } } // Special case - if setting a property where there exists a shadow property already AND the new prop is NOT default - blow away the shadow property! if (value != null && _shadowPropCount > 0 && propName[0] != KeyService.SHADOW_PROP_PREFIX && _valueBag.ContainsKey(KeyService.SHADOW_PROP_PREFIX + propName)) { var defVal = WrappingHelper.GetDefaultForType(value.GetType()); if (!defVal.IsSame(value)) { var k = KeyService.SHADOW_PROP_PREFIX + propName; if (_valueBag.ContainsKey(k)) { _valueBag.Remove(k); _shadowPropCount--; } } } wl.Release(); if (_source != null) { var info = _source.FastGetAllProperties(true, true, propName); if (info.Any()) { wl.Reacquire(); var oldVal = _source.FastGetValue(propName); if (!oldVal.IsSame(value)) { _source.FastSetValue(propName, InternalChangeType(value, info.First().type)); wl.Release(); OnPropertyChanged(propName, oldVal, value, false); return(true); } return(false); } } wl.Reacquire(); if (_valueBag.ContainsKey(propName)) { if (propName[0] != KeyService.SHADOW_PROP_PREFIX) { var oldVal = _valueBag[propName]; if (!oldVal.IsSame(value)) { _isBagChanged = true; _valueBag[propName] = value; wl.Release(); OnPropertyChanged(propName, oldVal, value, true); return(true); } } return(false); } _valueBag[propName] = value; if (propName[0] == KeyService.SHADOW_PROP_PREFIX) { _shadowPropCount++; return(false); } _isBagChanged = true; wl.Release(); OnPropertyChanged(propName, null, value, true); return(true); } }
private void SenderThread() { // mark this thread as a background thread Thread.CurrentThread.IsBackground = true; Thread.CurrentThread.Name = "Dataset sender thread"; // keep track of client to remove List <IPEndPoint> removeList = new List <IPEndPoint>(); // enter the send queue lock Monitor.Enter(sendQueue); while (true) { if (sendQueue.Count == 0) { Monitor.Wait(sendQueue); } // assume that now there is an entry in the queue if (sendQueue.Count > 0) { // dequeue the entry SendQueueEntry entry = sendQueue.Dequeue(); // fill up the buffer until we're at our target size while (sendQueue.Count > 0) { SendQueueEntry nextEntry = sendQueue.Peek(); if (entry.length + nextEntry.length <= target_packet_size) { // add in this entry // actually dequeue the entry sendQueue.Dequeue(); // copy the next entry into our working buffer Buffer.BlockCopy(nextEntry.buffer, 0, entry.buffer, entry.length, nextEntry.length); // update the entry length entry.length += nextEntry.length; // free the next entry buffer FreeBuffer(nextEntry.buffer); } else { // leave the loop, adding the next packet would go over the target size break; } } // increment the packet count and byte count packetCount++; // release the lock Monitor.Exit(sendQueue); try { // acquire a reader lock using (ReaderLock rl = new ReaderLock(listenerRWLock)) { // clear the remove list removeList.Clear(); // iterate through the listeners and send to each of them foreach (IPEndPoint listener in listenerEndPoints) { try { sender.SendTo(entry.buffer, entry.length, SocketFlags.None, listener); byteCount += entry.length; } catch (Exception) { // for any client error, add to the remove list removeList.Add(listener); } } // if there are listeners to remove, acquire a writer lock and remove them // only wait for 20 milliseconds to get the writer lock to avoid blocking using (WriterLock wl = rl.UpgradeToWriter(20)) { foreach (IPEndPoint ep in removeList) { listenerEndPoints.Remove(ep); } } doSendDataValues = listenerEndPoints.Count > 0; } } catch (Exception) { // ignore any exceptions } finally { // re-enter the send queue lock Monitor.Enter(sendQueue); } // free the buffer entry FreeBuffer(entry.buffer); } } }
public ReadWriteLock(LockRecursionPolicy policy = LockRecursionPolicy.SupportsRecursion) { _lock = new ReaderWriterLockSlim(policy); _rlock = new ReaderLock(this); _wlock = new WriterLock(this); }
private void ReleaseWriterLock(WriterLock locker) { _lock.ReleaseWriterLock(); lock (_lockers) _lockers.Remove(locker); }