// Token: 0x06006E18 RID: 28184 RVA: 0x0017A5A8 File Offset: 0x001787A8 public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent) { if (value != null || !treatNullValueAsNonexistent) { if (key == this._key1) { return(new AsyncLocalValueMap.TwoElementAsyncLocalValueMap(key, value, this._key2, this._value2)); } if (key != this._key2) { return(new AsyncLocalValueMap.ThreeElementAsyncLocalValueMap(this._key1, this._value1, this._key2, this._value2, key, value)); } return(new AsyncLocalValueMap.TwoElementAsyncLocalValueMap(this._key1, this._value1, key, value)); } else { if (key == this._key1) { return(new AsyncLocalValueMap.OneElementAsyncLocalValueMap(this._key2, this._value2)); } if (key != this._key2) { return(this); } return(new AsyncLocalValueMap.OneElementAsyncLocalValueMap(this._key1, this._value1)); } }
public IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent) { if (value != null || !treatNullValueAsNonexistent) { // If the key matches one already contained in this map, then create a new three-element map with the // updated value. if (ReferenceEquals(key, _key1)) return new ThreeElementAsyncLocalValueMap(key, value, _key2, _value2, _key3, _value3); if (ReferenceEquals(key, _key2)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, key, value, _key3, _value3); if (ReferenceEquals(key, _key3)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value); // The key doesn't exist in this map, so upgrade to a multi map that contains // the additional key/value pair. var multi = new MultiElementAsyncLocalValueMap(4); multi.UnsafeStore(0, _key1, _value1); multi.UnsafeStore(1, _key2, _value2); multi.UnsafeStore(2, _key3, _value3); multi.UnsafeStore(3, key, value); return multi; } else { // If the key exists in this map, remove it by downgrading to a two-element map without the key. Otherwise, // there's nothing to add or remove, so just return this map. return ReferenceEquals(key, _key1) ? new TwoElementAsyncLocalValueMap(_key2, _value2, _key3, _value3) : ReferenceEquals(key, _key2) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key3, _value3) : ReferenceEquals(key, _key3) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key2, _value2) : (IAsyncLocalValueMap)this; } }
// Token: 0x06006E17 RID: 28183 RVA: 0x0017A583 File Offset: 0x00178783 public TwoElementAsyncLocalValueMap(IAsyncLocal key1, object value1, IAsyncLocal key2, object value2) { this._key1 = key1; this._value1 = value1; this._key2 = key2; this._value2 = value2; }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext current = t_currentMaybeNull ?? ExecutionContext.Default; object previousValue; bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) { return; } current = new ExecutionContext(current); current.m_localValues[local] = newValue; t_currentMaybeNull = current; if (needChangeNotifications) { if (hadPreviousValue) { Debug.Assert(current.m_localChangeNotifications.Contains(local)); } else { current.m_localChangeNotifications.Add(local); } local.OnValueChanged(previousValue, newValue, false); } }
public IAsyncLocalValueMap Set(IAsyncLocal key, object?value, bool treatNullValueAsNonexistent) { // If the value isn't null or a null value may not be treated as nonexistent, then create a new one-element map // to store the key/value pair. Otherwise, use the empty map. return(value != null || !treatNullValueAsNonexistent ? new OneElementAsyncLocalValueMap(key, value) : (IAsyncLocalValueMap)this); }
public IAsyncLocalValueMap Set(IAsyncLocal key, object value) { // If the value isn't null, then create a new one-element map to store // the key/value pair. If it is null, then we're still empty. return(value != null ? new OneElementAsyncLocalValueMap(key, value) : (IAsyncLocalValueMap)this); }
// Token: 0x06006E11 RID: 28177 RVA: 0x0017A4D8 File Offset: 0x001786D8 public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent) { if (value == null && treatNullValueAsNonexistent) { return(this); } return(new AsyncLocalValueMap.OneElementAsyncLocalValueMap(key, value)); }
// Token: 0x06003A69 RID: 14953 RVA: 0x000DDB08 File Offset: 0x000DBD08 public static IAsyncLocalValueMap Create(IAsyncLocal key, object value, bool treatNullValueAsNonexistent) { if (value == null && treatNullValueAsNonexistent) { return(AsyncLocalValueMap.Empty); } return(new AsyncLocalValueMap.OneElementAsyncLocalValueMap(key, value)); }
private ExecutionContext( Dictionary<IAsyncLocal, object> localValues, IAsyncLocal[] localChangeNotifications, bool isFlowSuppressed) { m_localValues = localValues; m_localChangeNotifications = localChangeNotifications; m_isFlowSuppressed = isFlowSuppressed; }
private ExecutionContext( IAsyncLocalValueMap localValues, IAsyncLocal[] localChangeNotifications, bool isFlowSuppressed) { m_localValues = localValues; m_localChangeNotifications = localChangeNotifications; m_isFlowSuppressed = isFlowSuppressed; }
// Token: 0x06006E1A RID: 28186 RVA: 0x0017A684 File Offset: 0x00178884 public ThreeElementAsyncLocalValueMap(IAsyncLocal key1, object value1, IAsyncLocal key2, object value2, IAsyncLocal key3, object value3) { this._key1 = key1; this._value1 = value1; this._key2 = key2; this._value2 = value2; this._key3 = key3; this._value3 = value3; }
// Token: 0x06006E16 RID: 28182 RVA: 0x0017A56A File Offset: 0x0017876A public bool TryGetValue(IAsyncLocal key, out object value) { if (key == this._key1) { value = this._value1; return(true); } value = null; return(false); }
internal static object GetLocalValue(IAsyncLocal local) { ExecutionContext current = Thread.CurrentThread.ExecutionContext; if (current == null) { return(null); } current.m_localValues.TryGetValue(local, out object value); return(value); }
public bool TryGetValue(IAsyncLocal key, out object value) { if (ReferenceEquals(key, _key1)) { value = _value1; return(true); } else { value = null; return(false); } }
public bool TryGetValue(IAsyncLocal key, out object value) { foreach (KeyValuePair <IAsyncLocal, object> pair in _keyValues) { if (ReferenceEquals(key, pair.Key)) { value = pair.Value; return(true); } } value = null; return(false); }
// Token: 0x06006E20 RID: 28192 RVA: 0x0017ABE0 File Offset: 0x00178DE0 public bool TryGetValue(IAsyncLocal key, out object value) { foreach (KeyValuePair <IAsyncLocal, object> keyValuePair in this._keyValues) { if (key == keyValuePair.Key) { value = keyValuePair.Value; return(true); } } value = null; return(false); }
internal static object GetLocalValue(IAsyncLocal local) { ExecutionContext current = t_currentMaybeNull; if (current == null) { return(null); } object value; current.m_localValues.TryGetValue(local, out value); return(value); }
public object GetLocalValue(IAsyncLocal local) { if (this.IsNull) { return((object)null); } if (this.m_ec._localValues == null) { return((object)null); } object obj; this.m_ec._localValues.TryGetValue(local, out obj); return(obj); }
public object GetLocalValue(IAsyncLocal local) { if (this.IsNull) { return(null); } if (this.m_ec._localValues == null) { return(null); } object result; this.m_ec._localValues.TryGetValue(local, out result); return(result); }
public bool TryGetValue(IAsyncLocal key, out object? value) { if (ReferenceEquals(key, _key1)) { value = _value1; return true; } else if (ReferenceEquals(key, _key2)) { value = _value2; return true; } else { value = null; return false; } }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext mutableExecutionContext = Thread.CurrentThread.GetMutableExecutionContext(); object obj = null; bool flag = mutableExecutionContext._localValues != null && mutableExecutionContext._localValues.TryGetValue(local, out obj); if (obj == newValue) { return; } IAsyncLocalValueMap asyncLocalValueMap = mutableExecutionContext._localValues; if (asyncLocalValueMap == null) { asyncLocalValueMap = AsyncLocalValueMap.Create(local, newValue, !needChangeNotifications); } else { asyncLocalValueMap = asyncLocalValueMap.Set(local, newValue, !needChangeNotifications); } mutableExecutionContext._localValues = asyncLocalValueMap; if (needChangeNotifications) { if (!flag) { IAsyncLocal[] array = mutableExecutionContext._localChangeNotifications; if (array == null) { array = new IAsyncLocal[] { local }; } else { int num = array.Length; Array.Resize <IAsyncLocal>(ref array, num + 1); array[num] = local; } mutableExecutionContext._localChangeNotifications = array; } local.OnValueChanged(obj, newValue, false); } }
public IAsyncLocalValueMap Set(IAsyncLocal key, object?value, bool treatNullValueAsNonexistent) { if (value != null || !treatNullValueAsNonexistent) { // If the key matches one already contained in this map, then create a new one-element map with the updated // value, otherwise create a two-element map with the additional key/value. return(ReferenceEquals(key, _key1) ? new OneElementAsyncLocalValueMap(key, value) : (IAsyncLocalValueMap) new TwoElementAsyncLocalValueMap(_key1, _value1, key, value)); } else { // If the key exists in this map, remove it by downgrading to an empty map. Otherwise, there's nothing to // add or remove, so just return this map. return(ReferenceEquals(key, _key1) ? Empty : (IAsyncLocalValueMap)this); } }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext executionContext1 = Thread.CurrentThread.GetMutableExecutionContext(); object previousValue = (object)null; bool flag = executionContext1._localValues != null && executionContext1._localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) { return; } if (executionContext1._localValues == null) { executionContext1._localValues = new Dictionary <IAsyncLocal, object>(); } else { ExecutionContext executionContext2 = executionContext1; Dictionary <IAsyncLocal, object> dictionary = new Dictionary <IAsyncLocal, object>((IDictionary <IAsyncLocal, object>)executionContext2._localValues); executionContext2._localValues = dictionary; } executionContext1._localValues[local] = newValue; if (!needChangeNotifications) { return; } if (!flag) { if (executionContext1._localChangeNotifications == null) { executionContext1._localChangeNotifications = new List <IAsyncLocal>(); } else { ExecutionContext executionContext2 = executionContext1; List <IAsyncLocal> asyncLocalList = new List <IAsyncLocal>((IEnumerable <IAsyncLocal>)executionContext2._localChangeNotifications); executionContext2._localChangeNotifications = asyncLocalList; } executionContext1._localChangeNotifications.Add(local); } local.OnValueChanged(previousValue, newValue, false); }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext current = Thread.CurrentThread.ExecutionContext ?? ExecutionContext.Default; object previousValue; bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) { return; } IAsyncLocalValueMap newValues = current.m_localValues.Set(local, newValue); // // Either copy the change notification array, or create a new one, depending on whether we need to add a new item. // IAsyncLocal[] newChangeNotifications = current.m_localChangeNotifications; if (needChangeNotifications) { if (hadPreviousValue) { Contract.Assert(Array.IndexOf(newChangeNotifications, local) >= 0); } else { int newNotificationIndex = newChangeNotifications.Length; Array.Resize(ref newChangeNotifications, newNotificationIndex + 1); newChangeNotifications[newNotificationIndex] = local; } } Thread.CurrentThread.ExecutionContext = new ExecutionContext(newValues, newChangeNotifications, current.m_isFlowSuppressed); if (needChangeNotifications) { local.OnValueChanged(previousValue, newValue, false); } }
// Token: 0x06006E1B RID: 28187 RVA: 0x0017A6BC File Offset: 0x001788BC public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent) { if (value != null || !treatNullValueAsNonexistent) { if (key == this._key1) { return(new AsyncLocalValueMap.ThreeElementAsyncLocalValueMap(key, value, this._key2, this._value2, this._key3, this._value3)); } if (key == this._key2) { return(new AsyncLocalValueMap.ThreeElementAsyncLocalValueMap(this._key1, this._value1, key, value, this._key3, this._value3)); } if (key == this._key3) { return(new AsyncLocalValueMap.ThreeElementAsyncLocalValueMap(this._key1, this._value1, this._key2, this._value2, key, value)); } AsyncLocalValueMap.MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap = new AsyncLocalValueMap.MultiElementAsyncLocalValueMap(4); multiElementAsyncLocalValueMap.UnsafeStore(0, this._key1, this._value1); multiElementAsyncLocalValueMap.UnsafeStore(1, this._key2, this._value2); multiElementAsyncLocalValueMap.UnsafeStore(2, this._key3, this._value3); multiElementAsyncLocalValueMap.UnsafeStore(3, key, value); return(multiElementAsyncLocalValueMap); } else { if (key == this._key1) { return(new AsyncLocalValueMap.TwoElementAsyncLocalValueMap(this._key2, this._value2, this._key3, this._value3)); } if (key == this._key2) { return(new AsyncLocalValueMap.TwoElementAsyncLocalValueMap(this._key1, this._value1, this._key3, this._value3)); } if (key != this._key3) { return(this); } return(new AsyncLocalValueMap.TwoElementAsyncLocalValueMap(this._key1, this._value1, this._key2, this._value2)); } }
public IAsyncLocalValueMap Set(IAsyncLocal key, object value) { if (value != null) { // The value is non-null. If the key matches one already contained in this map, // then create a new two-element map with the updated value, otherwise create // a three-element map with the additional key/value. return (ReferenceEquals(key, _key1) ? new TwoElementAsyncLocalValueMap(key, value, _key2, _value2) : ReferenceEquals(key, _key2) ? new TwoElementAsyncLocalValueMap(_key1, _value1, key, value) : (IAsyncLocalValueMap) new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value)); } else { // The value is null. If the key exists in this map, remove it by downgrading to a one-element map // without the key. Otherwise, there's nothing to add or remove, so just return this map. return (ReferenceEquals(key, _key1) ? new OneElementAsyncLocalValueMap(_key2, _value2) : ReferenceEquals(key, _key2) ? new OneElementAsyncLocalValueMap(_key1, _value1) : (IAsyncLocalValueMap)this); } }
public IAsyncLocalValueMap Set(IAsyncLocal key, object value) { // Find the key in this map. for (int i = 0; i < _keyValues.Length; i++) { if (ReferenceEquals(key, _keyValues[i].Key)) { // The key is in the map. If the value isn't null, then create a new map of the same // size that has all of the same pairs, with this new key/value pair overwriting the old. if (value != null) { var multi = new MultiElementAsyncLocalValueMap(_keyValues.Length); Array.Copy(_keyValues, 0, multi._keyValues, 0, _keyValues.Length); multi._keyValues[i] = new KeyValuePair <IAsyncLocal, object>(key, value); return(multi); } else if (_keyValues.Length == 4) { // The value is null, and we only have four elements, one of which we're removing, // so downgrade to a three-element map, without the matching element. return (i == 0 ? new ThreeElementAsyncLocalValueMap(_keyValues[1].Key, _keyValues[1].Value, _keyValues[2].Key, _keyValues[2].Value, _keyValues[3].Key, _keyValues[3].Value) : i == 1 ? new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[2].Key, _keyValues[2].Value, _keyValues[3].Key, _keyValues[3].Value) : i == 2 ? new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[1].Key, _keyValues[1].Value, _keyValues[3].Key, _keyValues[3].Value) : (IAsyncLocalValueMap) new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[1].Key, _keyValues[1].Value, _keyValues[2].Key, _keyValues[2].Value)); } else { // The value is null, and we have enough elements remaining to warrant a multi map. // Create a new one and copy all of the elements from this one, except the one to be removed. var multi = new MultiElementAsyncLocalValueMap(_keyValues.Length - 1); if (i != 0) { Array.Copy(_keyValues, 0, multi._keyValues, 0, i); } if (i != _keyValues.Length - 1) { Array.Copy(_keyValues, i + 1, multi._keyValues, i, _keyValues.Length - i - 1); } return(multi); } } } // The key does not already exist in this map. // If the value is null, then we can simply return this same map, as there's nothing to add or remove. if (value == null) { return(this); } // We need to create a new map that has the additional key/value pair. // If with the addition we can still fit in a multi map, create one. if (_keyValues.Length < MaxMultiElements) { var multi = new MultiElementAsyncLocalValueMap(_keyValues.Length + 1); Array.Copy(_keyValues, 0, multi._keyValues, 0, _keyValues.Length); multi._keyValues[_keyValues.Length] = new KeyValuePair <IAsyncLocal, object>(key, value); return(multi); } // Otherwise, upgrade to a many map. var many = new ManyElementAsyncLocalValueMap(MaxMultiElements + 1); foreach (KeyValuePair <IAsyncLocal, object> pair in _keyValues) { many[pair.Key] = pair.Value; } many[key] = value; return(many); }
internal void UnsafeStore(int index, IAsyncLocal key, object value) { Debug.Assert(index < _keyValues.Length); _keyValues[index] = new KeyValuePair <IAsyncLocal, object>(key, value); }
private ExecutionContext(Dictionary<IAsyncLocal, object> localValues, IAsyncLocal[] localChangeNotifications) { m_localValues = localValues; m_localChangeNotifications = localChangeNotifications; }
public ThreeElementAsyncLocalValueMap(IAsyncLocal key1, object?value1, IAsyncLocal key2, object?value2, IAsyncLocal key3, object?value3) { _key1 = key1; _value1 = value1; _key2 = key2; _value2 = value2; _key3 = key3; _value3 = value3; }
public bool TryGetValue(IAsyncLocal key, out object value) { value = null; return(false); }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext current = Thread.CurrentThread.ExecutionContext ?? ExecutionContext.Default; object previousValue; bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) return; // // Allocate a new Dictionary containing a copy of the old values, plus the new value. We have to do this manually to // minimize allocations of IEnumerators, etc. // Dictionary<IAsyncLocal, object> newValues = new Dictionary<IAsyncLocal, object>(current.m_localValues.Count + (hadPreviousValue ? 0 : 1)); foreach (KeyValuePair<IAsyncLocal, object> pair in current.m_localValues) newValues.Add(pair.Key, pair.Value); newValues[local] = newValue; // // Either copy the change notification array, or create a new one, depending on whether we need to add a new item. // IAsyncLocal[] newChangeNotifications = current.m_localChangeNotifications; if (needChangeNotifications) { if (hadPreviousValue) { Contract.Assert(Array.IndexOf(newChangeNotifications, local) >= 0); } else { int newNotificationIndex = newChangeNotifications.Length; Array.Resize(ref newChangeNotifications, newNotificationIndex + 1); newChangeNotifications[newNotificationIndex] = local; } } Thread.CurrentThread.ExecutionContext = new ExecutionContext(newValues, newChangeNotifications, current.m_isFlowSuppressed); if (needChangeNotifications) { local.OnValueChanged(previousValue, newValue, false); } }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext current = Thread.CurrentThread.ExecutionContext ?? ExecutionContext.Default; object previousValue; bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) return; IAsyncLocalValueMap newValues = current.m_localValues.Set(local, newValue); // // Either copy the change notification array, or create a new one, depending on whether we need to add a new item. // IAsyncLocal[] newChangeNotifications = current.m_localChangeNotifications; if (needChangeNotifications) { if (hadPreviousValue) { Contract.Assert(Array.IndexOf(newChangeNotifications, local) >= 0); } else { int newNotificationIndex = newChangeNotifications.Length; Array.Resize(ref newChangeNotifications, newNotificationIndex + 1); newChangeNotifications[newNotificationIndex] = local; } } Thread.CurrentThread.ExecutionContext = new ExecutionContext(newValues, newChangeNotifications, current.m_isFlowSuppressed); if (needChangeNotifications) { local.OnValueChanged(previousValue, newValue, false); } }
internal static object GetLocalValue(IAsyncLocal local) { ExecutionContext current = Thread.CurrentThread.ExecutionContext; if (current == null) return null; object value; current.m_localValues.TryGetValue(local, out value); return value; }
public object GetLocalValue(IAsyncLocal local) { if (IsNull) return null; if (m_ec._localValues == null) return null; object value; m_ec._localValues.TryGetValue(local, out value); return value; }
internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications) { ExecutionContext current = t_currentMaybeNull ?? ExecutionContext.Default; object previousValue; bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue); if (previousValue == newValue) return; current = new ExecutionContext(current); current.m_localValues[local] = newValue; t_currentMaybeNull = current; if (needChangeNotifications) { if (hadPreviousValue) Contract.Assert(current.m_localChangeNotifications.Contains(local)); else current.m_localChangeNotifications.Add(local); local.OnValueChanged(previousValue, newValue, false); } }
public OneElementAsyncLocalValueMap(IAsyncLocal key, object value) { _key1 = key; _value1 = value; }
public TwoElementAsyncLocalValueMap(IAsyncLocal key1, object?value1, IAsyncLocal key2, object?value2) { _key1 = key1; _value1 = value1; _key2 = key2; _value2 = value2; }