Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / xsp / System / Web / Util / ReadWriteSpinLock.cs / 1 / ReadWriteSpinLock.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Web.Util { using System.Threading; using System.Collections; using System.Globalization; using Microsoft.Win32; struct ReadWriteSpinLock { // // Fields // // _bits is layed out as follows: // // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 // +-+-+---------------------------+--------------------------------+ // |S|W| WriteLockCount | ReadLockCount | // +-+-+---------------------------+--------------------------------+ // where // // S - sign bit (always zero) - By having a sign bit, operations // on the ReadLockCount can use InterlockedIncrement/Decrement // // W - writer waiting bit - set by threads attempting write lock, preventing // any further threads from acquiring read locks. This attempts to hint // that updates have priority, but doesn't guarantee priority. // // WriteLockCount - Write lock recursion count // // ReadLockCount - Read lock recursion count // int _bits; int _id; // // Statics // static bool s_disableBusyWaiting = (SystemInfo.GetNumProcessCPUs() == 1); // // Constants // const int BACK_OFF_FACTORS_LENGTH = 13; static readonly double [] s_backOffFactors = new double [BACK_OFF_FACTORS_LENGTH] { 1.020, 0.965, 0.890, 1.065, 1.025, 1.115, 0.940, 0.995, 1.050, 1.080, 0.915, 0.980, 1.010 }; const int WRITER_WAITING_MASK = (int) 0x40000000; const int WRITE_COUNT_MASK = (int) 0x3FFF0000; const int READ_COUNT_MASK = (int) 0x0000FFFF; const int WRITER_WAITING_SHIFT = 30; const int WRITE_COUNT_SHIFT = 16; static bool WriterWaiting(int bits) {return ((bits & WRITER_WAITING_MASK) != 0);} static int WriteLockCount(int bits) {return ((bits & WRITE_COUNT_MASK) >> WRITE_COUNT_SHIFT);} static int ReadLockCount(int bits) {return (bits & READ_COUNT_MASK);} static bool NoWriters(int bits) {return ((bits & WRITE_COUNT_MASK) == 0);} static bool NoWritersOrWaitingWriters(int bits) {return ((bits & (WRITE_COUNT_MASK | WRITER_WAITING_MASK)) == 0);} static bool NoLocks(int bits) {return ((bits & ~WRITER_WAITING_MASK) == 0);} bool WriterWaiting() {return WriterWaiting(_bits);} int WriteLockCount() {return WriteLockCount(_bits);} int ReadLockCount() {return ReadLockCount(_bits);} bool NoWriters() {return NoWriters(_bits);} bool NoWritersOrWaitingWriters() {return NoWritersOrWaitingWriters(_bits);} bool NoLocks() {return NoLocks(_bits);} int CreateNewBits(bool writerWaiting, int writeCount, int readCount) { int bits = ((writeCount << WRITE_COUNT_SHIFT) | readCount); if (writerWaiting) { bits |= WRITER_WAITING_MASK; } return bits; } internal /*public*/ void AcquireReaderLock() { // This lock supports Writelock then Readlock // from the same thread (possibly from different functions). int threadId = Thread.CurrentThread.GetHashCode(); // Optimize for the common case by if (_TryAcquireReaderLock(threadId)) return; _Spin(true, threadId); Debug.Trace("Spinlock", "AcquireReaderLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } internal /*public*/ void AcquireWriterLock() { int threadId = Thread.CurrentThread.GetHashCode(); // Optimize for the common case by if (_TryAcquireWriterLock(threadId)) return; _Spin(false, threadId); Debug.Trace("Spinlock", "AcquireWriterLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } internal /*public*/ void ReleaseReaderLock() { #if DBG int id = _id; Debug.Assert(id == 0 || id == Thread.CurrentThread.GetHashCode(), "id == 0 || id == Thread.CurrentThread.GetHashCode()"); #endif int n = Interlocked.Decrement(ref _bits); Debug.Assert(n >= 0, "n >= 0"); Debug.Trace("Spinlock", "ReleaseReaderLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } void AlterWriteCountHoldingWriterLock(int oldBits, int delta) { int readLockCount = ReadLockCount(oldBits); int oldWriteLockCount = WriteLockCount(oldBits); int newWriteLockCount = oldWriteLockCount + delta; Debug.Assert(newWriteLockCount >= 0, "newWriteLockCount >= 0"); int newBits; int test; for (;;) { // // Since we own the lock, the only change that can be // made by another thread to _bits is to add the writer-waiting bit. // Debug.Assert(WriteLockCount(oldBits) == oldWriteLockCount, "WriteLockCount(oldBits) == oldWriteLockCount"); Debug.Assert(ReadLockCount(oldBits) == readLockCount, "ReadLockCount(oldBits) == readLockCount"); newBits = CreateNewBits(WriterWaiting(oldBits), newWriteLockCount, readLockCount); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) { break; } oldBits = test; } } internal /*public*/ void ReleaseWriterLock() { #if DBG int id = _id; Debug.Assert(id == Thread.CurrentThread.GetHashCode(), "id == Thread.CurrentThread.GetHashCode()"); #endif int oldBits = _bits; int writeLockCount = WriteLockCount(oldBits); Debug.Assert(writeLockCount > 0, "writeLockCount > 0"); if (writeLockCount == 1) { // Reset the id before releasing count so that // AcquireRead works correctly. _id = 0; } AlterWriteCountHoldingWriterLock(oldBits, -1); Debug.Trace("Spinlock", "ReleaseWriterLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } bool _TryAcquireWriterLock(int threadId) { int id = _id; int oldBits = _bits; int newBits; int test; if (id == threadId) { // we can just pound in the correct value AlterWriteCountHoldingWriterLock(oldBits, +1); return true; } if (id == 0 && NoLocks(oldBits)) { newBits = CreateNewBits(false, 1, 0); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) { id = _id; Debug.Assert(id == 0); _id = threadId; return true; } oldBits = test; } // If there is contention, make sure the WRITER_WAITING bit is set. // Note: this blocks readers from using a value that is about to be changed if (!WriterWaiting(oldBits)) { // hammer on _bits until the bit is set for (;;) { newBits = (oldBits | WRITER_WAITING_MASK); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) break; oldBits = test; } } return false; } bool _TryAcquireReaderLock(int threadId) { int oldBits = _bits; int id = _id; if (id == 0) { if (!NoWriters(oldBits)) { return false; } } else if (id != threadId) { return false; } if (Interlocked.CompareExchange(ref _bits, oldBits + 1, oldBits) == oldBits) { return true; } return false; } ///void _Spin(bool isReaderLock, int threadId) { const int LOCK_MAXIMUM_SPINS = 10000; // maximum allowable spin count const int LOCK_DEFAULT_SPINS = 4000; // default spin count const int LOCK_MINIMUM_SPINS = 100; // minimum allowable spin count int sleepTime = 0; int baseSpins; { // limit scope of temp. stack vars to calculation of baseSpin2 // Alternatives for threadId include a static counter // or the low DWORD of QueryPerformanceCounter(). double randomBackoffFactor = s_backOffFactors[Math.Abs(threadId) % BACK_OFF_FACTORS_LENGTH]; baseSpins = (int)(LOCK_DEFAULT_SPINS * randomBackoffFactor); baseSpins = Math.Min(LOCK_MAXIMUM_SPINS, baseSpins); baseSpins = Math.Max(baseSpins, LOCK_MINIMUM_SPINS); } DateTime utcSpinStartTime = DateTime.UtcNow; // error if struct not initialized // hand-optimize loop: Increase locality by copying static variables // onto the stack (this will reduce cache misses after a contact // switch induced by Sleep()). bool disableBusyWaiting = s_disableBusyWaiting; for (;;) { if (isReaderLock) { if (_TryAcquireReaderLock(threadId)) { break; } } else { if (_TryAcquireWriterLock(threadId)) { break; } } // if 1 cpu, or cpu affinity is set to 1, spinning is a waste of time if (disableBusyWaiting) { Thread.Sleep(sleepTime); // Avoid priority inversion: 0, 1, 0, 1,... sleepTime ^= 1; } else { int spinCount = baseSpins; // Check no more than baseSpins times then yield. // It is important not to use the InterlockedExchange in the // inner loop in order to minimize system memory bus traffic. for(;;) { // // If the lock is available break spinning and // try to obtain it. // if (isReaderLock) { if (NoWritersOrWaitingWriters()) { break; } } else { if (NoLocks()) { break; } } if (--spinCount < 0) { Thread.Sleep(sleepTime); // Backoff algorithm: reduce (or increase) busy wait time baseSpins /= 2; // LOCK_MINIMUM_SPINS <= baseSpins <= LOCK_MAXIMUM_SPINS //baseSpins = Math.Min(LOCK_MAXIMUM_SPINS, baseSpins); //= min(LOCK_MAXIMUM_SPINS, baseSpins) baseSpins = Math.Max(baseSpins, LOCK_MINIMUM_SPINS); //= max(baseSpins, LOCK_MINIMUM_SPINS); spinCount = baseSpins; // Using Sleep(0) leads to the possibility of priority // inversion. Sleep(0) only yields the processor if // there's another thread of the same priority that's // ready to run. If a high-priority thread is trying to // acquire the lock, which is held by a low-priority // thread, then the low-priority thread may never get // scheduled and hence never free the lock. NT attempts // to avoid priority inversions by temporarily boosting // the priority of low-priority runnable threads, but the // problem can still occur if there's a medium-priority // thread that's always runnable. If Sleep(1) is used, // then the thread unconditionally yields the CPU. We // only do this for the second and subsequent even // iterations, since a millisecond is a long time to wait // if the thread can be scheduled in again sooner // (~100,000 instructions). // Avoid priority inversion: 0, 1, 0, 1,... sleepTime ^= 1; } else { // kill about 20 clock cycles on this proc Thread.SpinWait(10); } } } }// while }// _Spin } // ReadWriteSpinLock } // namespace System.Web.Util // NOTES: // // This ReaderWriterSpinlock is a combination of the // original lightweight (4 byte) System.Web.Util.ReadWriteSpinLock // and the lightweight (4 byte) exclusive lock (SmallSpinLock) used // in the George Reilly's LKRHash (see http://georgere/work/lkrhash). // // In an effort to support reentrancy during writes we are squirreling // away the thread id of the thread holding the write lock into the upper // 16 bits of the lock count. This is possible as long as thread ids stay // smaller than 7FFF. Anything higher than that would flip the sign bit // and we'd no longer be able to do signed comparisons to check // for read vs. write. // // read write // lower #read locks #write locks (from same thread) // higher 0x0000 thread id of thread holding lock // // Adapted from LKRHash's lock.cpp, from GeorgeRe // The original implementation is due to PALarson. // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //------------------------------------------------------------------------------ // // Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Web.Util { using System.Threading; using System.Collections; using System.Globalization; using Microsoft.Win32; struct ReadWriteSpinLock { // // Fields // // _bits is layed out as follows: // // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 // +-+-+---------------------------+--------------------------------+ // |S|W| WriteLockCount | ReadLockCount | // +-+-+---------------------------+--------------------------------+ // where // // S - sign bit (always zero) - By having a sign bit, operations // on the ReadLockCount can use InterlockedIncrement/Decrement // // W - writer waiting bit - set by threads attempting write lock, preventing // any further threads from acquiring read locks. This attempts to hint // that updates have priority, but doesn't guarantee priority. // // WriteLockCount - Write lock recursion count // // ReadLockCount - Read lock recursion count // int _bits; int _id; // // Statics // static bool s_disableBusyWaiting = (SystemInfo.GetNumProcessCPUs() == 1); // // Constants // const int BACK_OFF_FACTORS_LENGTH = 13; static readonly double [] s_backOffFactors = new double [BACK_OFF_FACTORS_LENGTH] { 1.020, 0.965, 0.890, 1.065, 1.025, 1.115, 0.940, 0.995, 1.050, 1.080, 0.915, 0.980, 1.010 }; const int WRITER_WAITING_MASK = (int) 0x40000000; const int WRITE_COUNT_MASK = (int) 0x3FFF0000; const int READ_COUNT_MASK = (int) 0x0000FFFF; const int WRITER_WAITING_SHIFT = 30; const int WRITE_COUNT_SHIFT = 16; static bool WriterWaiting(int bits) {return ((bits & WRITER_WAITING_MASK) != 0);} static int WriteLockCount(int bits) {return ((bits & WRITE_COUNT_MASK) >> WRITE_COUNT_SHIFT);} static int ReadLockCount(int bits) {return (bits & READ_COUNT_MASK);} static bool NoWriters(int bits) {return ((bits & WRITE_COUNT_MASK) == 0);} static bool NoWritersOrWaitingWriters(int bits) {return ((bits & (WRITE_COUNT_MASK | WRITER_WAITING_MASK)) == 0);} static bool NoLocks(int bits) {return ((bits & ~WRITER_WAITING_MASK) == 0);} bool WriterWaiting() {return WriterWaiting(_bits);} int WriteLockCount() {return WriteLockCount(_bits);} int ReadLockCount() {return ReadLockCount(_bits);} bool NoWriters() {return NoWriters(_bits);} bool NoWritersOrWaitingWriters() {return NoWritersOrWaitingWriters(_bits);} bool NoLocks() {return NoLocks(_bits);} int CreateNewBits(bool writerWaiting, int writeCount, int readCount) { int bits = ((writeCount << WRITE_COUNT_SHIFT) | readCount); if (writerWaiting) { bits |= WRITER_WAITING_MASK; } return bits; } internal /*public*/ void AcquireReaderLock() { // This lock supports Writelock then Readlock // from the same thread (possibly from different functions). int threadId = Thread.CurrentThread.GetHashCode(); // Optimize for the common case by if (_TryAcquireReaderLock(threadId)) return; _Spin(true, threadId); Debug.Trace("Spinlock", "AcquireReaderLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } internal /*public*/ void AcquireWriterLock() { int threadId = Thread.CurrentThread.GetHashCode(); // Optimize for the common case by if (_TryAcquireWriterLock(threadId)) return; _Spin(false, threadId); Debug.Trace("Spinlock", "AcquireWriterLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } internal /*public*/ void ReleaseReaderLock() { #if DBG int id = _id; Debug.Assert(id == 0 || id == Thread.CurrentThread.GetHashCode(), "id == 0 || id == Thread.CurrentThread.GetHashCode()"); #endif int n = Interlocked.Decrement(ref _bits); Debug.Assert(n >= 0, "n >= 0"); Debug.Trace("Spinlock", "ReleaseReaderLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } void AlterWriteCountHoldingWriterLock(int oldBits, int delta) { int readLockCount = ReadLockCount(oldBits); int oldWriteLockCount = WriteLockCount(oldBits); int newWriteLockCount = oldWriteLockCount + delta; Debug.Assert(newWriteLockCount >= 0, "newWriteLockCount >= 0"); int newBits; int test; for (;;) { // // Since we own the lock, the only change that can be // made by another thread to _bits is to add the writer-waiting bit. // Debug.Assert(WriteLockCount(oldBits) == oldWriteLockCount, "WriteLockCount(oldBits) == oldWriteLockCount"); Debug.Assert(ReadLockCount(oldBits) == readLockCount, "ReadLockCount(oldBits) == readLockCount"); newBits = CreateNewBits(WriterWaiting(oldBits), newWriteLockCount, readLockCount); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) { break; } oldBits = test; } } internal /*public*/ void ReleaseWriterLock() { #if DBG int id = _id; Debug.Assert(id == Thread.CurrentThread.GetHashCode(), "id == Thread.CurrentThread.GetHashCode()"); #endif int oldBits = _bits; int writeLockCount = WriteLockCount(oldBits); Debug.Assert(writeLockCount > 0, "writeLockCount > 0"); if (writeLockCount == 1) { // Reset the id before releasing count so that // AcquireRead works correctly. _id = 0; } AlterWriteCountHoldingWriterLock(oldBits, -1); Debug.Trace("Spinlock", "ReleaseWriterLock: _bits=" + _bits.ToString("x8", CultureInfo.InvariantCulture) + " _id= " + _id.ToString("x8", CultureInfo.InvariantCulture)); } bool _TryAcquireWriterLock(int threadId) { int id = _id; int oldBits = _bits; int newBits; int test; if (id == threadId) { // we can just pound in the correct value AlterWriteCountHoldingWriterLock(oldBits, +1); return true; } if (id == 0 && NoLocks(oldBits)) { newBits = CreateNewBits(false, 1, 0); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) { id = _id; Debug.Assert(id == 0); _id = threadId; return true; } oldBits = test; } // If there is contention, make sure the WRITER_WAITING bit is set. // Note: this blocks readers from using a value that is about to be changed if (!WriterWaiting(oldBits)) { // hammer on _bits until the bit is set for (;;) { newBits = (oldBits | WRITER_WAITING_MASK); test = Interlocked.CompareExchange(ref _bits, newBits, oldBits); if (test == oldBits) break; oldBits = test; } } return false; } bool _TryAcquireReaderLock(int threadId) { int oldBits = _bits; int id = _id; if (id == 0) { if (!NoWriters(oldBits)) { return false; } } else if (id != threadId) { return false; } if (Interlocked.CompareExchange(ref _bits, oldBits + 1, oldBits) == oldBits) { return true; } return false; } ///void _Spin(bool isReaderLock, int threadId) { const int LOCK_MAXIMUM_SPINS = 10000; // maximum allowable spin count const int LOCK_DEFAULT_SPINS = 4000; // default spin count const int LOCK_MINIMUM_SPINS = 100; // minimum allowable spin count int sleepTime = 0; int baseSpins; { // limit scope of temp. stack vars to calculation of baseSpin2 // Alternatives for threadId include a static counter // or the low DWORD of QueryPerformanceCounter(). double randomBackoffFactor = s_backOffFactors[Math.Abs(threadId) % BACK_OFF_FACTORS_LENGTH]; baseSpins = (int)(LOCK_DEFAULT_SPINS * randomBackoffFactor); baseSpins = Math.Min(LOCK_MAXIMUM_SPINS, baseSpins); baseSpins = Math.Max(baseSpins, LOCK_MINIMUM_SPINS); } DateTime utcSpinStartTime = DateTime.UtcNow; // error if struct not initialized // hand-optimize loop: Increase locality by copying static variables // onto the stack (this will reduce cache misses after a contact // switch induced by Sleep()). bool disableBusyWaiting = s_disableBusyWaiting; for (;;) { if (isReaderLock) { if (_TryAcquireReaderLock(threadId)) { break; } } else { if (_TryAcquireWriterLock(threadId)) { break; } } // if 1 cpu, or cpu affinity is set to 1, spinning is a waste of time if (disableBusyWaiting) { Thread.Sleep(sleepTime); // Avoid priority inversion: 0, 1, 0, 1,... sleepTime ^= 1; } else { int spinCount = baseSpins; // Check no more than baseSpins times then yield. // It is important not to use the InterlockedExchange in the // inner loop in order to minimize system memory bus traffic. for(;;) { // // If the lock is available break spinning and // try to obtain it. // if (isReaderLock) { if (NoWritersOrWaitingWriters()) { break; } } else { if (NoLocks()) { break; } } if (--spinCount < 0) { Thread.Sleep(sleepTime); // Backoff algorithm: reduce (or increase) busy wait time baseSpins /= 2; // LOCK_MINIMUM_SPINS <= baseSpins <= LOCK_MAXIMUM_SPINS //baseSpins = Math.Min(LOCK_MAXIMUM_SPINS, baseSpins); //= min(LOCK_MAXIMUM_SPINS, baseSpins) baseSpins = Math.Max(baseSpins, LOCK_MINIMUM_SPINS); //= max(baseSpins, LOCK_MINIMUM_SPINS); spinCount = baseSpins; // Using Sleep(0) leads to the possibility of priority // inversion. Sleep(0) only yields the processor if // there's another thread of the same priority that's // ready to run. If a high-priority thread is trying to // acquire the lock, which is held by a low-priority // thread, then the low-priority thread may never get // scheduled and hence never free the lock. NT attempts // to avoid priority inversions by temporarily boosting // the priority of low-priority runnable threads, but the // problem can still occur if there's a medium-priority // thread that's always runnable. If Sleep(1) is used, // then the thread unconditionally yields the CPU. We // only do this for the second and subsequent even // iterations, since a millisecond is a long time to wait // if the thread can be scheduled in again sooner // (~100,000 instructions). // Avoid priority inversion: 0, 1, 0, 1,... sleepTime ^= 1; } else { // kill about 20 clock cycles on this proc Thread.SpinWait(10); } } } }// while }// _Spin } // ReadWriteSpinLock } // namespace System.Web.Util // NOTES: // // This ReaderWriterSpinlock is a combination of the // original lightweight (4 byte) System.Web.Util.ReadWriteSpinLock // and the lightweight (4 byte) exclusive lock (SmallSpinLock) used // in the George Reilly's LKRHash (see http://georgere/work/lkrhash). // // In an effort to support reentrancy during writes we are squirreling // away the thread id of the thread holding the write lock into the upper // 16 bits of the lock count. This is possible as long as thread ids stay // smaller than 7FFF. Anything higher than that would flip the sign bit // and we'd no longer be able to do signed comparisons to check // for read vs. write. // // read write // lower #read locks #write locks (from same thread) // higher 0x0000 thread id of thread holding lock // // Adapted from LKRHash's lock.cpp, from GeorgeRe // The original implementation is due to PALarson. // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- IndentTextWriter.cs
- FileAccessException.cs
- MostlySingletonList.cs
- DataGridRowDetailsEventArgs.cs
- XmlAttributeAttribute.cs
- SqlDataSourceConnectionPanel.cs
- ImportCatalogPart.cs
- RayMeshGeometry3DHitTestResult.cs
- MexHttpsBindingCollectionElement.cs
- Font.cs
- NonVisualControlAttribute.cs
- Module.cs
- RC2.cs
- ReflectionPermission.cs
- DecoderFallback.cs
- WCFBuildProvider.cs
- DescendantQuery.cs
- SecurityKeyUsage.cs
- SortableBindingList.cs
- HtmlImage.cs
- StaticFileHandler.cs
- WebConfigurationHost.cs
- OleDbFactory.cs
- DesignerAutoFormat.cs
- EventArgs.cs
- DeflateStreamAsyncResult.cs
- MouseEvent.cs
- MemberHolder.cs
- ADConnectionHelper.cs
- CryptographicAttribute.cs
- ConfigXmlComment.cs
- CodeIterationStatement.cs
- DataGridViewCellValueEventArgs.cs
- TableLayoutSettingsTypeConverter.cs
- DrawingAttributeSerializer.cs
- Geometry3D.cs
- CultureSpecificStringDictionary.cs
- EnglishPluralizationService.cs
- CallContext.cs
- TableLayoutPanel.cs
- DefaultProxySection.cs
- EmbossBitmapEffect.cs
- RtfToken.cs
- EntityDataSourceDesignerHelper.cs
- EventSinkActivityDesigner.cs
- TraceInternal.cs
- AssociationSet.cs
- _NetworkingPerfCounters.cs
- NavigationExpr.cs
- NetworkInterface.cs
- DataGridColumnStyleMappingNameEditor.cs
- OdbcEnvironmentHandle.cs
- QfeChecker.cs
- XMLSchema.cs
- AuthenticationManager.cs
- RealProxy.cs
- CompModSwitches.cs
- ConfigurationValues.cs
- ConfigurationLocationCollection.cs
- PeerMessageDispatcher.cs
- Soap.cs
- DataGridViewCellStyle.cs
- CompilerGlobalScopeAttribute.cs
- BackStopAuthenticationModule.cs
- HttpInputStream.cs
- processwaithandle.cs
- BaseCollection.cs
- FontCollection.cs
- DataViewManagerListItemTypeDescriptor.cs
- MorphHelper.cs
- BitArray.cs
- ModuleBuilderData.cs
- MetadataUtil.cs
- PassportPrincipal.cs
- PointAnimationUsingPath.cs
- FormsIdentity.cs
- CngUIPolicy.cs
- Signature.cs
- HtmlProps.cs
- Int32CollectionValueSerializer.cs
- ColumnResult.cs
- NameSpaceExtractor.cs
- Converter.cs
- ModelPropertyImpl.cs
- HtmlInputReset.cs
- AnnouncementDispatcherAsyncResult.cs
- TimeSpanOrInfiniteConverter.cs
- CodeCastExpression.cs
- TableLayoutPanel.cs
- XmlWriterTraceListener.cs
- TextReader.cs
- DependentList.cs
- ProfileSection.cs
- DataKeyCollection.cs
- HtmlInputImage.cs
- Int32AnimationBase.cs
- TextControlDesigner.cs
- DictionaryContent.cs
- BufferModeSettings.cs
- InvalidPrinterException.cs