private bool SetValueFast(object?value, DependencyPropertyValuePrecedences precedence)
{
if (_stack == null && precedence == DependencyPropertyValuePrecedences.Local)
{
var valueIsUnsetValue = value is UnsetValue;
if (HasWeakStorage)
{
if (_fastLocalValue is ManagedWeakReference mwr2)
{
WeakReferencePool.ReturnWeakReference(this, mwr2);
}
_fastLocalValue = Validate(value);
}
else
{
_fastLocalValue = ValidateNoWrap(value);
}
_highestPrecedence = valueIsUnsetValue
? DependencyPropertyValuePrecedences.DefaultValue
: DependencyPropertyValuePrecedences.Local;
return(true);
}
return(false);
}
/// <summary>
/// Sets the value at the given level in the stack
/// </summary>
/// <param name="value">The value to set</param>
/// <param name="precedence">The precedence level to set the value at</param>
internal void SetValue(object value, DependencyPropertyValuePrecedences precedence)
{
if (_hasWeakStorage && _stack[(int)precedence] is ManagedWeakReference mwr)
{
WeakReferencePool.ReturnWeakReference(this, mwr);
}
_stack[(int)precedence] = Validate(value);
// After setting the value, we need to update the current highest precedence if needed
// If a higher value precedence was set, then this is the new highest
if (!(value is UnsetValue) && precedence < _highestPrecedence)
{
_highestPrecedence = precedence;
return;
}
// If we were unsetting the current highest precedence value, we need to find the next highest
if (value is UnsetValue && precedence == _highestPrecedence)
{
// Start from current precedence and find next highest
for (int i = (int)precedence; i < (int)DependencyPropertyValuePrecedences.DefaultValue; i++)
{
if (_stack[i] != DependencyProperty.UnsetValue)
{
_highestPrecedence = (DependencyPropertyValuePrecedences)i;
return;
}
}
_highestPrecedence = DependencyPropertyValuePrecedences.DefaultValue;
}
}
public void When_Null_Target()
{
var mr1 = WeakReferencePool.RentWeakReference(this, null);
WeakReferencePool.ReturnWeakReference(this, mr1);
Assert.AreEqual(1, WeakReferencePool.PooledReferences);
}
internal void SetDirectManipulationStateChangeHandler(IDirectManipulationStateChangeHandler?handler)
{
_directManipulationHandlerSubscription?.Dispose();
if (handler is null)
{
return;
}
var weakHandler = WeakReferencePool.RentWeakReference(this, handler);
UpdatesMode = ScrollViewerUpdatesMode.Synchronous;
ViewChanged += OnViewChanged;
_directManipulationHandlerSubscription = Disposable.Create(() =>
{
ViewChanged -= OnViewChanged;
WeakReferencePool.ReturnWeakReference(this, weakHandler);
});
void OnViewChanged(object?sender, ScrollViewerViewChangedEventArgs args)
{
if (args.IsIntermediate)
{
return;
}
if (weakHandler.Target is IDirectManipulationStateChangeHandler h)
{
h.NotifyStateChange(DMManipulationState.DMManipulationCompleted, default, default, default, default, default, default, default, default);
public void When_Null_Target_And_Owner()
{
var o1 = new Object();
var mr1 = WeakReferencePool.RentWeakReference(null, null);
WeakReferencePool.ReturnWeakReference(null, mr1);
Assert.AreEqual(0, WeakReferencePool.PooledReferences);
}
public void When_WeakReferenceProvider_Collected()
{
var o1 = new Object();
void test1()
{
var mr1 = WeakReferencePool.RentWeakReference(this, o1);
WeakReferencePool.ReturnWeakReference(this, mr1);
}
test1();
Assert.AreEqual(2, WeakReferencePool.PooledReferences);
void test2()
{
var mr2 = WeakReferencePool.RentWeakReference(this, o1);
WeakReferencePool.ReturnWeakReference(this, mr2);
}
test2();
Assert.AreEqual(2, WeakReferencePool.PooledReferences);
(WeakReference refref, WeakReference ownerRef, WeakReference targetRef) CreateUnreferenced()
{
var o2 = new Object();
var mr2 = WeakReferencePool.RentWeakReference(o1, o2);
return(new WeakReference(mr2), new WeakReference(mr2.GetUnsafeOwnerHandle()), new WeakReference(mr2.GetUnsafeTargetHandle()));
}
var r = CreateUnreferenced();
Assert.IsNotNull(r.ownerRef.Target);
Assert.IsNotNull(r.targetRef.Target);
Assert.IsNotNull(r.refref.Target);
Assert.AreEqual(0, WeakReferencePool.PooledReferences);
GCCondition(5, () => r.refref.Target == null);
Assert.IsNull(r.refref.Target);
GCCondition(5, () => r.ownerRef.Target == null && r.targetRef.Target == null);
Assert.IsNull(r.ownerRef.Target);
Assert.IsNull(r.targetRef.Target);
Assert.AreEqual(0, WeakReferencePool.PooledReferences);
}
public void When_WeakReferenceProvider_Reused()
{
var o1 = new Object();
var mr1 = WeakReferencePool.RentWeakReference(this, o1);
WeakReferencePool.ReturnWeakReference(this, mr1);
var target = new MyProvider();
Assert.AreEqual(target, target.WeakReference.Target);
var mr2 = WeakReferencePool.RentWeakReference(target, o1);
WeakReferencePool.ReturnWeakReference(target, mr2);
Assert.AreEqual(target, target.WeakReference.Target);
}
private void SetValueFull(object?value, DependencyPropertyValuePrecedences precedence)
{
var valueIsUnsetValue = value is UnsetValue;
var stackAlias = Stack;
if (HasWeakStorage)
{
if (stackAlias[(int)precedence] is ManagedWeakReference mwr)
{
WeakReferencePool.ReturnWeakReference(this, mwr);
}
stackAlias[(int)precedence] = Validate(value);
}
else
{
stackAlias[(int)precedence] = ValidateNoWrap(value);
}
// After setting the value, we need to update the current highest precedence if needed
// If a higher value precedence was set, then this is the new highest
if (!valueIsUnsetValue && precedence < _highestPrecedence)
{
_highestPrecedence = precedence;
return;
}
// If we were unsetting the current highest precedence value, we need to find the next highest
if (valueIsUnsetValue && precedence == _highestPrecedence)
{
// Start from current precedence and find next highest
for (int i = (int)precedence; i < (int)DependencyPropertyValuePrecedences.DefaultValue; i++)
{
if (stackAlias[i] != DependencyProperty.UnsetValue)
{
_highestPrecedence = (DependencyPropertyValuePrecedences)i;
return;
}
}
_highestPrecedence = DependencyPropertyValuePrecedences.DefaultValue;
}
}
public void When_Not_Owned_Returned()
{
var target1 = new object();
var target2 = new object();
var mr1 = WeakReferencePool.RentWeakReference(target1, target1);
var wr = mr1.GetUnsafeTargetHandle();
Assert.AreEqual(target1, mr1.GetUnsafeTargetHandle().Target);
Assert.AreEqual(target1, mr1.Owner);
WeakReferencePool.ReturnWeakReference(this, mr1);
var mr2 = WeakReferencePool.RentWeakReference(this, target2);
Assert.AreEqual(target2, mr2.GetUnsafeTargetHandle().Target);
Assert.AreEqual(this, mr2.Owner);
Assert.AreNotSame(wr, mr2.GetUnsafeTargetHandle());
}