diff options
Diffstat (limited to 'src/System.Private.CoreLib/shared/System/Threading/ThreadLocal.cs')
-rw-r--r-- | src/System.Private.CoreLib/shared/System/Threading/ThreadLocal.cs | 781 |
1 files changed, 781 insertions, 0 deletions
diff --git a/src/System.Private.CoreLib/shared/System/Threading/ThreadLocal.cs b/src/System.Private.CoreLib/shared/System/Threading/ThreadLocal.cs new file mode 100644 index 000000000..9f4beae9c --- /dev/null +++ b/src/System.Private.CoreLib/shared/System/Threading/ThreadLocal.cs @@ -0,0 +1,781 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Generic; +using System.Diagnostics; + +// A class that provides a simple, lightweight implementation of thread-local lazy-initialization, where a value is initialized once per accessing +// thread; this provides an alternative to using a ThreadStatic static variable and having +// to check the variable prior to every access to see if it's been initialized. + +namespace System.Threading +{ + /// <summary> + /// Provides thread-local storage of data. + /// </summary> + /// <typeparam name="T">Specifies the type of data stored per-thread.</typeparam> + /// <remarks> + /// <para> + /// With the exception of <see cref="Dispose()"/>, all public and protected members of + /// <see cref="ThreadLocal{T}"/> are thread-safe and may be used + /// concurrently from multiple threads. + /// </para> + /// </remarks> + [DebuggerTypeProxy(typeof(SystemThreading_ThreadLocalDebugView<>))] + [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueForDebugDisplay}, Count={ValuesCountForDebugDisplay}")] + public class ThreadLocal<T> : IDisposable + { + // a delegate that returns the created value, if null the created value will be default(T) + private Func<T> _valueFactory; + + // ts_slotArray is a table of thread-local values for all ThreadLocal<T> instances + // + // So, when a thread reads ts_slotArray, it gets back an array of *all* ThreadLocal<T> values for this thread and this T. + // The slot relevant to this particular ThreadLocal<T> instance is determined by the _idComplement instance field stored in + // the ThreadLocal<T> instance. + [ThreadStatic] + private static LinkedSlotVolatile[] ts_slotArray; + + [ThreadStatic] + private static FinalizationHelper ts_finalizationHelper; + + // Slot ID of this ThreadLocal<> instance. We store a bitwise complement of the ID (that is ~ID), which allows us to distinguish + // between the case when ID is 0 and an incompletely initialized object, either due to a thread abort in the constructor, or + // possibly due to a memory model issue in user code. + private int _idComplement; + + // This field is set to true when the constructor completes. That is helpful for recognizing whether a constructor + // threw an exception - either due to invalid argument or due to a thread abort. Finally, the field is set to false + // when the instance is disposed. + private volatile bool _initialized; + + // IdManager assigns and reuses slot IDs. Additionally, the object is also used as a global lock. + private static IdManager s_idManager = new IdManager(); + + // A linked list of all values associated with this ThreadLocal<T> instance. + // We create a dummy head node. That allows us to remove any (non-dummy) node without having to locate the m_linkedSlot field. + private LinkedSlot _linkedSlot = new LinkedSlot(null); + + // Whether the Values property is supported + private bool _trackAllValues; + + /// <summary> + /// Initializes the <see cref="System.Threading.ThreadLocal{T}"/> instance. + /// </summary> + public ThreadLocal() + { + Initialize(null, false); + } + + /// <summary> + /// Initializes the <see cref="System.Threading.ThreadLocal{T}"/> instance. + /// </summary> + /// <param name="trackAllValues">Whether to track all values set on the instance and expose them through the Values property.</param> + public ThreadLocal(bool trackAllValues) + { + Initialize(null, trackAllValues); + } + + + /// <summary> + /// Initializes the <see cref="System.Threading.ThreadLocal{T}"/> instance with the + /// specified <paramref name="valueFactory"/> function. + /// </summary> + /// <param name="valueFactory"> + /// The <see cref="T:System.Func{T}"/> invoked to produce a lazily-initialized value when + /// an attempt is made to retrieve <see cref="Value"/> without it having been previously initialized. + /// </param> + /// <exception cref="T:System.ArgumentNullException"> + /// <paramref name="valueFactory"/> is a null reference (Nothing in Visual Basic). + /// </exception> + public ThreadLocal(Func<T> valueFactory) + { + if (valueFactory == null) + throw new ArgumentNullException(nameof(valueFactory)); + + Initialize(valueFactory, false); + } + + /// <summary> + /// Initializes the <see cref="System.Threading.ThreadLocal{T}"/> instance with the + /// specified <paramref name="valueFactory"/> function. + /// </summary> + /// <param name="valueFactory"> + /// The <see cref="T:System.Func{T}"/> invoked to produce a lazily-initialized value when + /// an attempt is made to retrieve <see cref="Value"/> without it having been previously initialized. + /// </param> + /// <param name="trackAllValues">Whether to track all values set on the instance and expose them via the Values property.</param> + /// <exception cref="T:System.ArgumentNullException"> + /// <paramref name="valueFactory"/> is a null reference (Nothing in Visual Basic). + /// </exception> + public ThreadLocal(Func<T> valueFactory, bool trackAllValues) + { + if (valueFactory == null) + throw new ArgumentNullException(nameof(valueFactory)); + + Initialize(valueFactory, trackAllValues); + } + + private void Initialize(Func<T> valueFactory, bool trackAllValues) + { + _valueFactory = valueFactory; + _trackAllValues = trackAllValues; + + // Assign the ID and mark the instance as initialized. To avoid leaking IDs, we assign the ID and set _initialized + // in a finally block, to avoid a thread abort in between the two statements. + try { } + finally + { + _idComplement = ~s_idManager.GetId(); + + // As the last step, mark the instance as fully initialized. (Otherwise, if _initialized=false, we know that an exception + // occurred in the constructor.) + _initialized = true; + } + } + + /// <summary> + /// Releases the resources used by this <see cref="T:System.Threading.ThreadLocal{T}" /> instance. + /// </summary> + ~ThreadLocal() + { + // finalizer to return the type combination index to the pool + Dispose(false); + } + + #region IDisposable Members + + /// <summary> + /// Releases the resources used by this <see cref="T:System.Threading.ThreadLocal{T}" /> instance. + /// </summary> + /// <remarks> + /// Unlike most of the members of <see cref="T:System.Threading.ThreadLocal{T}"/>, this method is not thread-safe. + /// </remarks> + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// <summary> + /// Releases the resources used by this <see cref="T:System.Threading.ThreadLocal{T}" /> instance. + /// </summary> + /// <param name="disposing"> + /// A Boolean value that indicates whether this method is being called due to a call to <see cref="Dispose()"/>. + /// </param> + /// <remarks> + /// Unlike most of the members of <see cref="T:System.Threading.ThreadLocal{T}"/>, this method is not thread-safe. + /// </remarks> + protected virtual void Dispose(bool disposing) + { + int id; + + lock (s_idManager) + { + id = ~_idComplement; + _idComplement = 0; + + if (id < 0 || !_initialized) + { + Debug.Assert(id >= 0 || !_initialized, "expected id >= 0 if initialized"); + + // Handle double Dispose calls or disposal of an instance whose constructor threw an exception. + return; + } + _initialized = false; + + for (LinkedSlot linkedSlot = _linkedSlot._next; linkedSlot != null; linkedSlot = linkedSlot._next) + { + LinkedSlotVolatile[] slotArray = linkedSlot._slotArray; + + if (slotArray == null) + { + // The thread that owns this slotArray has already finished. + continue; + } + + // Remove the reference from the LinkedSlot to the slot table. + linkedSlot._slotArray = null; + + // And clear the references from the slot table to the linked slot and the value so that + // both can get garbage collected. + slotArray[id].Value._value = default; + slotArray[id].Value = null; + } + } + _linkedSlot = null; + s_idManager.ReturnId(id); + } + + #endregion + + /// <summary>Creates and returns a string representation of this instance for the current thread.</summary> + /// <returns>The result of calling <see cref="System.Object.ToString"/> on the <see cref="Value"/>.</returns> + /// <exception cref="T:System.NullReferenceException"> + /// The <see cref="Value"/> for the current thread is a null reference (Nothing in Visual Basic). + /// </exception> + /// <exception cref="T:System.InvalidOperationException"> + /// The initialization function referenced <see cref="Value"/> in an improper manner. + /// </exception> + /// <exception cref="T:System.ObjectDisposedException"> + /// The <see cref="ThreadLocal{T}"/> instance has been disposed. + /// </exception> + /// <remarks> + /// Calling this method forces initialization for the current thread, as is the + /// case with accessing <see cref="Value"/> directly. + /// </remarks> + public override string ToString() + { + return Value.ToString(); + } + + /// <summary> + /// Gets or sets the value of this instance for the current thread. + /// </summary> + /// <exception cref="T:System.InvalidOperationException"> + /// The initialization function referenced <see cref="Value"/> in an improper manner. + /// </exception> + /// <exception cref="T:System.ObjectDisposedException"> + /// The <see cref="ThreadLocal{T}"/> instance has been disposed. + /// </exception> + /// <remarks> + /// If this instance was not previously initialized for the current thread, + /// accessing <see cref="Value"/> will attempt to initialize it. If an initialization function was + /// supplied during the construction, that initialization will happen by invoking the function + /// to retrieve the initial value for <see cref="Value"/>. Otherwise, the default value of + /// <typeparamref name="T"/> will be used. + /// </remarks> + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + public T Value + { + get + { + LinkedSlotVolatile[] slotArray = ts_slotArray; + LinkedSlot slot; + int id = ~_idComplement; + + // + // Attempt to get the value using the fast path + // + if (slotArray != null // Has the slot array been initialized? + && id >= 0 // Is the ID non-negative (i.e., instance is not disposed)? + && id < slotArray.Length // Is the table large enough? + && (slot = slotArray[id].Value) != null // Has a LinkedSlot object has been allocated for this ID? + && _initialized // Has the instance *still* not been disposed (important for a race condition with Dispose)? + ) + { + // We verified that the instance has not been disposed *after* we got a reference to the slot. + // This guarantees that we have a reference to the right slot. + // + // Volatile read of the LinkedSlotVolatile.Value property ensures that the m_initialized read + // will not be reordered before the read of slotArray[id]. + return slot._value; + } + + return GetValueSlow(); + } + set + { + LinkedSlotVolatile[] slotArray = ts_slotArray; + LinkedSlot slot; + int id = ~_idComplement; + + // Attempt to set the value using the fast path + if (slotArray != null // Has the slot array been initialized? + && id >= 0 // Is the ID non-negative (i.e., instance is not disposed)? + && id < slotArray.Length // Is the table large enough? + && (slot = slotArray[id].Value) != null // Has a LinkedSlot object has been allocated for this ID? + && _initialized // Has the instance *still* not been disposed (important for a race condition with Dispose)? + ) + { + // We verified that the instance has not been disposed *after* we got a reference to the slot. + // This guarantees that we have a reference to the right slot. + // + // Volatile read of the LinkedSlotVolatile.Value property ensures that the m_initialized read + // will not be reordered before the read of slotArray[id]. + slot._value = value; + } + else + { + SetValueSlow(value, slotArray); + } + } + } + + private T GetValueSlow() + { + // If the object has been disposed, the id will be -1. + int id = ~_idComplement; + if (id < 0) + { + throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + } + + Debugger.NotifyOfCrossThreadDependency(); + + // Determine the initial value + T value; + if (_valueFactory == null) + { + value = default; + } + else + { + value = _valueFactory(); + + if (IsValueCreated) + { + throw new InvalidOperationException(SR.ThreadLocal_Value_RecursiveCallsToValue); + } + } + + // Since the value has been previously uninitialized, we also need to set it (according to the ThreadLocal semantics). + Value = value; + return value; + } + + private void SetValueSlow(T value, LinkedSlotVolatile[] slotArray) + { + int id = ~_idComplement; + + // If the object has been disposed, id will be -1. + if (id < 0) + { + throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + } + + // If a slot array has not been created on this thread yet, create it. + if (slotArray == null) + { + slotArray = new LinkedSlotVolatile[GetNewTableSize(id + 1)]; + ts_finalizationHelper = new FinalizationHelper(slotArray, _trackAllValues); + ts_slotArray = slotArray; + } + + // If the slot array is not big enough to hold this ID, increase the table size. + if (id >= slotArray.Length) + { + GrowTable(ref slotArray, id + 1); + ts_finalizationHelper.SlotArray = slotArray; + ts_slotArray = slotArray; + } + + // If we are using the slot in this table for the first time, create a new LinkedSlot and add it into + // the linked list for this ThreadLocal instance. + if (slotArray[id].Value == null) + { + CreateLinkedSlot(slotArray, id, value); + } + else + { + // Volatile read of the LinkedSlotVolatile.Value property ensures that the m_initialized read + // that follows will not be reordered before the read of slotArray[id]. + LinkedSlot slot = slotArray[id].Value; + + // It is important to verify that the ThreadLocal instance has not been disposed. The check must come + // after capturing slotArray[id], but before assigning the value into the slot. This ensures that + // if this ThreadLocal instance was disposed on another thread and another ThreadLocal instance was + // created, we definitely won't assign the value into the wrong instance. + + if (!_initialized) + { + throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + } + + slot._value = value; + } + } + + /// <summary> + /// Creates a LinkedSlot and inserts it into the linked list for this ThreadLocal instance. + /// </summary> + private void CreateLinkedSlot(LinkedSlotVolatile[] slotArray, int id, T value) + { + // Create a LinkedSlot + var linkedSlot = new LinkedSlot(slotArray); + + // Insert the LinkedSlot into the linked list maintained by this ThreadLocal<> instance and into the slot array + lock (s_idManager) + { + // Check that the instance has not been disposed. It is important to check this under a lock, since + // Dispose also executes under a lock. + if (!_initialized) + { + throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + } + + LinkedSlot firstRealNode = _linkedSlot._next; + + // Insert linkedSlot between nodes m_linkedSlot and firstRealNode. + // (_linkedSlot is the dummy head node that should always be in the front.) + linkedSlot._next = firstRealNode; + linkedSlot._previous = _linkedSlot; + linkedSlot._value = value; + + if (firstRealNode != null) + { + firstRealNode._previous = linkedSlot; + } + _linkedSlot._next = linkedSlot; + + // Assigning the slot under a lock prevents a race condition with Dispose (dispose also acquires the lock). + // Otherwise, it would be possible that the ThreadLocal instance is disposed, another one gets created + // with the same ID, and the write would go to the wrong instance. + slotArray[id].Value = linkedSlot; + } + } + + /// <summary> + /// Gets a list for all of the values currently stored by all of the threads that have accessed this instance. + /// </summary> + /// <exception cref="T:System.ObjectDisposedException"> + /// The <see cref="ThreadLocal{T}"/> instance has been disposed. + /// </exception> + public IList<T> Values + { + get + { + if (!_trackAllValues) + { + throw new InvalidOperationException(SR.ThreadLocal_ValuesNotAvailable); + } + + var list = GetValuesAsList(); // returns null if disposed + if (list == null) throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + return list; + } + } + + /// <summary>Gets all of the threads' values in a list.</summary> + private List<T> GetValuesAsList() + { + List<T> valueList = new List<T>(); + int id = ~_idComplement; + if (id == -1) + { + return null; + } + + // Walk over the linked list of slots and gather the values associated with this ThreadLocal instance. + for (LinkedSlot linkedSlot = _linkedSlot._next; linkedSlot != null; linkedSlot = linkedSlot._next) + { + // We can safely read linkedSlot.Value. Even if this ThreadLocal has been disposed in the meantime, the LinkedSlot + // objects will never be assigned to another ThreadLocal instance. + valueList.Add(linkedSlot._value); + } + + return valueList; + } + + /// <summary>Gets the number of threads that have data in this instance.</summary> + private int ValuesCountForDebugDisplay + { + get + { + int count = 0; + for (LinkedSlot linkedSlot = _linkedSlot._next; linkedSlot != null; linkedSlot = linkedSlot._next) + { + count++; + } + return count; + } + } + + /// <summary> + /// Gets whether <see cref="Value"/> is initialized on the current thread. + /// </summary> + /// <exception cref="T:System.ObjectDisposedException"> + /// The <see cref="ThreadLocal{T}"/> instance has been disposed. + /// </exception> + public bool IsValueCreated + { + get + { + int id = ~_idComplement; + if (id < 0) + { + throw new ObjectDisposedException(SR.ThreadLocal_Disposed); + } + + LinkedSlotVolatile[] slotArray = ts_slotArray; + return slotArray != null && id < slotArray.Length && slotArray[id].Value != null; + } + } + + + /// <summary>Gets the value of the ThreadLocal<T> for debugging display purposes. It takes care of getting + /// the value for the current thread in the ThreadLocal mode.</summary> + internal T ValueForDebugDisplay + { + get + { + LinkedSlotVolatile[] slotArray = ts_slotArray; + int id = ~_idComplement; + + LinkedSlot slot; + if (slotArray == null || id >= slotArray.Length || (slot = slotArray[id].Value) == null || !_initialized) + return default; + return slot._value; + } + } + + /// <summary>Gets the values of all threads that accessed the ThreadLocal<T>.</summary> + internal List<T> ValuesForDebugDisplay // same as Values property, but doesn't throw if disposed + { + get { return GetValuesAsList(); } + } + + /// <summary> + /// Resizes a table to a certain length (or larger). + /// </summary> + private void GrowTable(ref LinkedSlotVolatile[] table, int minLength) + { + Debug.Assert(table.Length < minLength); + + // Determine the size of the new table and allocate it. + int newLen = GetNewTableSize(minLength); + LinkedSlotVolatile[] newTable = new LinkedSlotVolatile[newLen]; + + // + // The lock is necessary to avoid a race with ThreadLocal.Dispose. GrowTable has to point all + // LinkedSlot instances referenced in the old table to reference the new table. Without locking, + // Dispose could use a stale SlotArray reference and clear out a slot in the old array only, while + // the value continues to be referenced from the new (larger) array. + // + lock (s_idManager) + { + for (int i = 0; i < table.Length; i++) + { + LinkedSlot linkedSlot = table[i].Value; + if (linkedSlot != null && linkedSlot._slotArray != null) + { + linkedSlot._slotArray = newTable; + newTable[i] = table[i]; + } + } + } + + table = newTable; + } + + /// <summary> + /// Chooses the next larger table size + /// </summary> + private static int GetNewTableSize(int minSize) + { + if ((uint)minSize > Array.MaxArrayLength) + { + // Intentionally return a value that will result in an OutOfMemoryException + return int.MaxValue; + } + Debug.Assert(minSize > 0); + + // + // Round up the size to the next power of 2 + // + // The algorithm takes three steps: + // input -> subtract one -> propagate 1-bits to the right -> add one + // + // Let's take a look at the 3 steps in both interesting cases: where the input + // is (Example 1) and isn't (Example 2) a power of 2. + // + // Example 1: 100000 -> 011111 -> 011111 -> 100000 + // Example 2: 011010 -> 011001 -> 011111 -> 100000 + // + int newSize = minSize; + + // Step 1: Decrement + newSize--; + + // Step 2: Propagate 1-bits to the right. + newSize |= newSize >> 1; + newSize |= newSize >> 2; + newSize |= newSize >> 4; + newSize |= newSize >> 8; + newSize |= newSize >> 16; + + // Step 3: Increment + newSize++; + + // Don't set newSize to more than Array.MaxArrayLength + if ((uint)newSize > Array.MaxArrayLength) + { + newSize = Array.MaxArrayLength; + } + + return newSize; + } + + /// <summary> + /// A wrapper struct used as LinkedSlotVolatile[] - an array of LinkedSlot instances, but with volatile semantics + /// on array accesses. + /// </summary> + private struct LinkedSlotVolatile + { + internal volatile LinkedSlot Value; + } + + /// <summary> + /// A node in the doubly-linked list stored in the ThreadLocal instance. + /// + /// The value is stored in one of two places: + /// + /// 1. If SlotArray is not null, the value is in SlotArray.Table[id] + /// 2. If SlotArray is null, the value is in FinalValue. + /// </summary> + private sealed class LinkedSlot + { + internal LinkedSlot(LinkedSlotVolatile[] slotArray) + { + _slotArray = slotArray; + } + + // The next LinkedSlot for this ThreadLocal<> instance + internal volatile LinkedSlot _next; + + // The previous LinkedSlot for this ThreadLocal<> instance + internal volatile LinkedSlot _previous; + + // The SlotArray that stores this LinkedSlot at SlotArray.Table[id]. + internal volatile LinkedSlotVolatile[] _slotArray; + + // The value for this slot. + internal T _value; + } + + /// <summary> + /// A manager class that assigns IDs to ThreadLocal instances + /// </summary> + private class IdManager + { + // The next ID to try + private int _nextIdToTry = 0; + + // Stores whether each ID is free or not. Additionally, the object is also used as a lock for the IdManager. + private List<bool> _freeIds = new List<bool>(); + + internal int GetId() + { + lock (_freeIds) + { + int availableId = _nextIdToTry; + while (availableId < _freeIds.Count) + { + if (_freeIds[availableId]) { break; } + availableId++; + } + + if (availableId == _freeIds.Count) + { + _freeIds.Add(false); + } + else + { + _freeIds[availableId] = false; + } + + _nextIdToTry = availableId + 1; + + return availableId; + } + } + + // Return an ID to the pool + internal void ReturnId(int id) + { + lock (_freeIds) + { + _freeIds[id] = true; + if (id < _nextIdToTry) _nextIdToTry = id; + } + } + } + + /// <summary> + /// A class that facilitates ThreadLocal cleanup after a thread exits. + /// + /// After a thread with an associated thread-local table has exited, the FinalizationHelper + /// is responsible for removing back-references to the table. Since an instance of FinalizationHelper + /// is only referenced from a single thread-local slot, the FinalizationHelper will be GC'd once + /// the thread has exited. + /// + /// The FinalizationHelper then locates all LinkedSlot instances with back-references to the table + /// (all those LinkedSlot instances can be found by following references from the table slots) and + /// releases the table so that it can get GC'd. + /// </summary> + private class FinalizationHelper + { + internal LinkedSlotVolatile[] SlotArray; + private bool _trackAllValues; + + internal FinalizationHelper(LinkedSlotVolatile[] slotArray, bool trackAllValues) + { + SlotArray = slotArray; + _trackAllValues = trackAllValues; + } + + ~FinalizationHelper() + { + LinkedSlotVolatile[] slotArray = SlotArray; + Debug.Assert(slotArray != null); + + for (int i = 0; i < slotArray.Length; i++) + { + LinkedSlot linkedSlot = slotArray[i].Value; + if (linkedSlot == null) + { + // This slot in the table is empty + continue; + } + + if (_trackAllValues) + { + // Set the SlotArray field to null to release the slot array. + linkedSlot._slotArray = null; + } + else + { + // Remove the LinkedSlot from the linked list. Once the FinalizationHelper is done, all back-references to + // the table will be have been removed, and so the table can get GC'd. + lock (s_idManager) + { + if (linkedSlot._next != null) + { + linkedSlot._next._previous = linkedSlot._previous; + } + + // Since the list uses a dummy head node, the Previous reference should never be null. + Debug.Assert(linkedSlot._previous != null); + linkedSlot._previous._next = linkedSlot._next; + } + } + } + } + } + } + + /// <summary>A debugger view of the ThreadLocal<T> to surface additional debugging properties and + /// to ensure that the ThreadLocal<T> does not become initialized if it was not already.</summary> + internal sealed class SystemThreading_ThreadLocalDebugView<T> + { + //The ThreadLocal object being viewed. + private readonly ThreadLocal<T> _tlocal; + + /// <summary>Constructs a new debugger view object for the provided ThreadLocal object.</summary> + /// <param name="tlocal">A ThreadLocal object to browse in the debugger.</param> + public SystemThreading_ThreadLocalDebugView(ThreadLocal<T> tlocal) + { + _tlocal = tlocal; + } + + /// <summary>Returns whether the ThreadLocal object is initialized or not.</summary> + public bool IsValueCreated => _tlocal.IsValueCreated; + + /// <summary>Returns the value of the ThreadLocal object.</summary> + public T Value => _tlocal.ValueForDebugDisplay; + + /// <summary>Return all values for all threads that have accessed this instance.</summary> + public List<T> Values => _tlocal.ValuesForDebugDisplay; + } +} |