private void AttachAcceptCommand(IFrameworkElement control)
{
var b = control.FindName("AcceptButton") as Button;
if (b != null && b.Command == null)
{
var wr = WeakReferencePool.RentWeakReference(this, this);
b.Command = new DelegateCommand(() => (wr.Target as TimePickerFlyout)?.Accept());
}
}
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 FrameworkTemplate(object?owner, FrameworkTemplateBuilder?factory)
{
InitializeBinder();
_viewFactory = factory;
_ownerRef = WeakReferencePool.RentWeakReference(this, owner);
// Compute the hash for this template once, it will be used a lot
// in the ControlPool's internal dictionary.
_hashCode = (factory?.Target?.GetHashCode() ?? 0) ^ (factory?.Method.GetHashCode() ?? 0);
_xamlScope = ResourceResolver.CurrentScope;
}
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;
}
}
private IDisposable AttachFlyoutCommand(string targetButtonName, Action <DatePickerFlyout> action)
{
if (_presenter.FindName(targetButtonName) is Button button)
{
if (button.Command == null)
{
var self = WeakReferencePool.RentSelfWeakReference(this);
button.Command = new DelegateCommand(() => (self.Target as DatePickerFlyout)?.Apply(action));
return(Disposable.Create(() =>
{
button.Command = null;
self.Dispose();
}));
}
}
return(Disposable.Empty);
}
private void UpdateTextBoxView()
{
if (_textBoxView == null && _contentElement != null)
{
_textBoxView = _contentElement.GetChildren().FirstOrDefault() as TextBoxView;
if (_textBoxView == null)
{
_textBoxView = new TextBoxView(this);
_contentElement.Content = _textBoxView;
_textBoxView.SetTextNative(Text);
_editableFactory = _editableFactory ?? new Factory(WeakReferencePool.RentSelfWeakReference(this));
_textBoxView.SetEditableFactory(_editableFactory);
}
SetupTextBoxView();
}
}
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());
}
public TextBoxView(TextBox owner)
: base(ContextHelper.Current)
{
_ownerRef = WeakReferencePool.RentWeakReference(this, owner);
InitializeBinder();
base.SetSingleLine(true);
//This Background color is set to remove the native android underline on the EditText.
this.SetBackgroundColor(Colors.Transparent);
//Remove default native padding.
this.SetPadding(0, 0, 0, 0);
_isInitialized = true;
// This ensures the TextBoxView gets resized as Text changes
LayoutParameters = new Android.Views.ViewGroup.LayoutParams(
Android.Views.ViewGroup.LayoutParams.WrapContent,
Android.Views.ViewGroup.LayoutParams.WrapContent
);
}
private object Wrap(object value)
=> _hasWeakStorage && value != null && value != DependencyProperty.UnsetValue
? WeakReferencePool.RentWeakReference(this, value)
: value;
public MyProvider()
{
WeakReference = WeakReferencePool.RentSelfWeakReference(this);
}
public void Cleanup()
{
WeakReferencePool.ClearCache();
}
public void Initialize()
{
WeakReferencePool.ClearCache();
}
public void RegisterName(string name, object scopedElement)
{
_names.Add(name, WeakReferencePool.RentWeakReference(this, scopedElement));
}
public static void ReturnWeakReferenceToPool(WeakReference wr)
{
#if ENABLE_OBJ_POOL
WeakReferencePool.ReturnToPool(wr);
#endif
}
public WeakResourceInitializer(object owner, ResourceInitializerWithOwner initializer)
{
_owner = WeakReferencePool.RentWeakReference(this, owner);
Initializer = () => initializer(_owner?.Target);
}
