public bool GetTargetTest()
{
CreateArrays();
WeakReference weakarray = new WeakReference(array); // array has only weak reference
// obj has both strong and weak ref and so should not get collected
WeakReference weakobj = new WeakReference(obj);
GCHandle objhandle = GCHandle.Alloc(obj, GCHandleType.Normal);
DestroyArrays();
GC.Collect();
Object target1 = weakarray.Target; // should be null
Object target2 = weakobj.Target; // should be System.Object[]
Console.WriteLine("{0},{1}", target1, target2);
if ((target1 == null) && (target2 != null))
{
Console.WriteLine("Test for WeakReference.get_Target passed!");
return true;
}
else
{
Console.WriteLine("Test for WeakReference.get_Target failed!");
return false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DependencyObserver"/> class.
/// </summary>
/// <param name="messageHandler">The message handler.</param>
/// <param name="methodFactory">The method factory.</param>
/// <param name="notifier">The notifier.</param>
public DependencyObserver(IRoutedMessageHandler messageHandler, IMethodFactory methodFactory, INotifyPropertyChanged notifier)
{
_messageHandler = messageHandler;
_methodFactory = methodFactory;
_weakNotifier = new WeakReference<INotifyPropertyChanged>(notifier);
_monitoringInfos = new Dictionary<string, MonitoringInfo>();
}
private void MetadataCachingWithGarbageCollectionTemplate(Action garbageCollection)
{
MetadataWorkspace.ClearCache();
var weakReferences = new WeakReference[3];
// load metadata
using (var connection1 = new EntityConnection(connectionString))
{
connection1.Open();
weakReferences[0] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
weakReferences[1] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
weakReferences[2] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
}
// perform necessary garbage collection steps
garbageCollection();
// verify that metadata was cached
using (var connection2 = new EntityConnection(connectionString))
{
connection2.Open();
Assert.Same(weakReferences[0].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
Assert.Same(weakReferences[1].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
Assert.Same(weakReferences[2].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
}
}
public static int Main() {
CreateArray();
WeakReference weak = new WeakReference(array);
bool ans1 = weak.IsAlive;
Console.WriteLine(ans1);
if(ans1==false) { // GC.Collect() has already occurred..under GCStress
Console.WriteLine("Test for WeakReference.IsAlive passed!");
return 100;
}
//else, do an expicit collect.
DestroyArray();
GC.Collect();
bool ans2 = weak.IsAlive;
Console.WriteLine(ans2);
if((ans1 == true) && (ans2==false)) {
Console.WriteLine("Test for WeakReference.IsAlive passed!");
return 100;
}
else {
Console.WriteLine("Test for WeakReference.IsAlive failed!");
return 1;
}
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: Call Ctor with valid target reference and set trackResurrection to false");
try
{
Object obj = new Object();
WeakReference reference = new WeakReference(obj, false);
if ((reference.TrackResurrection != false) || (!reference.Target.Equals(obj)) )
{
TestLibrary.TestFramework.LogError("001.1", "Calling Ctor with valid target reference and set trackResurrection to false constructs wrong instance");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] reference.TrackResurrection = " + reference.TrackResurrection.ToString() +
", reference.Target = " + reference.Target.ToString() +
", obj = " + obj.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
// ATTENTION!!! ATTENTION!!! ATTENTION!!!
//
// If you encounter issues with object lifetime, please see more comments in WeakReferenceCtor2.cs
public bool PosTest1()
{
bool retVal = true;
TestFramework.BeginScenario("Test IsAlive with short WeakReference");
try
{
WeakReference extWR = new WeakReference(WRHelper.CreateAnObject("Test"), false);
if (!extWR.IsAlive)
{
TestFramework.LogError("001", "WeakReference IsAlive not as expected. Expected : True; Actual: " + extWR.IsAlive);
retVal = false;
}
GC.Collect();
GC.WaitForPendingFinalizers();
//Dev10 Bug #413556: WeakReference object incorrectly kept alive. Enable after the test is fixed.
//
//if (extWR.IsAlive)
//{
// TestFramework.LogError("002", "WeakReference IsAlive not as expected. Expected : False; Actual: " + extWR.IsAlive);
// retVal = false;
//}
}
catch (Exception e)
{
TestFramework.LogError("003", "Unexpected exception occured: " + e);
retVal = false;
}
return retVal;
}
public bool GetTargetTest()
{
int[] array = new int[50];
Object[] obj = new Object[25];
WeakReference weakarray = new WeakReference(array); // array has only weak reference
// obj has both strong and weak ref and so should not get collected
WeakReference weakobj = new WeakReference(obj);
GCHandle objhandle = GCHandle.Alloc(obj, GCHandleType.Normal);
// ensuring GC.Collect() occurs even with /debug option
array = null;
obj = null;
GC.Collect();
Object target1 = weakarray.Target; // should be null
Object target2 = weakobj.Target; // should be System.Object[]
Console.WriteLine("{0},{1}", target1, target2);
if ((target1 == null) && (target2 != null))
{
Console.WriteLine("Test for WeakReference.get_Target passed!");
return true;
}
else
{
Console.WriteLine("Test for WeakReference.get_Target failed!");
return false;
}
}
public static bool VerifyObject(WeakReference wr, string s)
{
if (((myClass)wr.Target).myString != s)
return false;
else
return true;
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: TrackResurrection will return correct value when construct the WeakReference for an object instance");
try
{
Object obj = new Object();
WeakReference reference = new WeakReference(obj, true);
if (!reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("001.1", "TrackResurrection returns false when construct the WeakReference for an object instance");
retVal = false;
}
reference = new WeakReference(obj, false);
if (reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("001.2", "TrackResurrection returns true when construct the WeakReference for an object instance");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
static void Swap(ref WeakReference refNmsp, object o)
{
WeakReference wref = refNmsp;
if (wref != null)
{
Console.WriteLine ("Need this to make it pass");
}
Interlocked.CompareExchange<WeakReference>(ref refNmsp, new WeakReference(o), wref);
}
static void SetupLinks () {
var a = new Bridge () { id = "bridge" };
var b = new Bridge () { id = "child" };
a.link.Add (b);
a.__test = 1;
b.__test = 0;
root = new WeakReference<Bridge> (a, true);
child = new WeakReference<Bridge> (b, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionMessageHandler"/> class.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="target">The target.</param>
public ActionMessageHandler(IActionHost host, object target)
{
_weakTarget = new WeakReference<object>(target);
_host = host;
_host.SelectMany(x => x.Filters.HandlerAware)
.Union(_host.Filters.HandlerAware)
.Apply(x => x.MakeAwareOf(this));
}
public void doWork()
{
ServiceProvider service;
if((provider == null) || !provider.TryGetTarget(out service)){
service = new ServiceProvider();
provider = new WeakReference<ServiceProvider>(service); // !!!!! podem evitar instanciar uma nova WeakReference fazendo o SetTarget(T)
}
service.doWork();
}
internal ObjectViewListener(IObjectView view, IList list, object dataSource)
{
_viewWeak = new WeakReference(view);
_dataSource = dataSource;
_list = list;
RegisterCollectionEvents();
RegisterEntityEvents();
}
void ListenDestroy(Destroyable _destroyable)
{
m_CharacterRef = null;
if (networkView != null && networkView.enabled)
Network.RemoveRPCs(networkView.viewID);
if (postDestroy != null)
postDestroy (this, _destroyable.GetComponent<Character>());
}
public DebugComponent(Game game)
: base(game)
{
// Load up our content manager
content = new ContentManager(game.Services);
// Create the very first weak ref instance for GC checking.
// This will be dealt with in Update() from now on.
this.weakReference = new WeakReference(new object());
}
public void PruneTest()
{
var strongSwitch = new TestSwitch();
var weakSwitch = new WeakReference(new TestSwitch());
Assert.True(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
Assert.False(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
}
static void SetupLinks () {
var r = new Toggleref () { id = "root" };
var c = new Toggleref () { id = "child" };
r.link.Add (c);
r.__test = Toggleref.STRONG;
c.__test = Toggleref.WEAK;
Register (r);
Register (c);
root = new WeakReference<Toggleref> (r, false);
child = new WeakReference<Toggleref> (c, false);
}
static int Main ()
{
WeakReference wr = new WeakReference (new MainForm ());
Application.Run ((Form) wr.Target);
GC.Collect ();
System.Threading.Thread.Sleep (200);
GC.Collect ();
return wr.IsAlive ? 1 : 0;
}
float _nPropValueStart; // Value of our CProp at start of 'quick mouse edit'
#endregion Fields
#region Constructors
public CKeyHook(CProp oProp, KeyCode oKeyCode, EKeyHookType eKeyHookType, string sDescription, float nRatio=1.0f, bool bSelectedBodyOnly = true)
{
_oProp = oProp;
_oKeyCode = oKeyCode;
_eKeyHookType = eKeyHookType;
_sDescription = sDescription;
_nRatio = nRatio;
_bSelectedBodyOnly = bSelectedBodyOnly;
_oWeakRef = new WeakReference(this, false);
CGame.INSTANCE._aKeyHooks.Add(_oWeakRef); //###NOTE: Add a weak reference to CGame so that it can automatically remove dead objects as the owner of this CKeyHook destroys us.
}
static void SetupLinks () {
var a = new Toggleref () { id = "root" };
var b = new Toggleref () { id = "child" };
a.link.Add (b);
a.__test = Toggleref.STRONG;
b.__test = Toggleref.WEAK;
Register (a);
Register (b);
root = new WeakReference<Toggleref> (a, false);
child = new WeakReference<Toggleref> (b, false);
}
static UnpackedObjectCache()
{
Dead = new WeakReference<Entry>(null);
_maxByteCount = new WindowCacheConfig().DeltaBaseCacheLimit;
Cache = new Slot[CacheSize];
for (int i = 0; i < CacheSize; i++)
{
Cache[i] = new Slot();
}
}
public void PruneTest()
{
var strongTrace = new TraceSource("TestTraceSource");
var traceRef = new WeakReference(new TraceSource("TestTraceSource"));
Assert.True(traceRef.IsAlive);
GC.Collect(2);
Trace.Refresh();
Assert.False(traceRef.IsAlive);
GC.Collect(2);
Trace.Refresh();
}
public Path(Vector2[] points) {
this.points = points;
m_Adherent = null;
segmentLengths = new float[points.Length];
length = 0;
for (int i = 0; i < points.Length; i++) {
Vector2 p1 = points[i];
Vector2 p2 = points[(i + 1) % points.Length];
float segmentLength = Vector2.Distance(p1, p2);
length += segmentLength;
segmentLengths[i] = segmentLength;
}
}
internal SqlInternalTransaction(SqlInternalConnection innerConnection, TransactionType type, SqlTransaction outerTransaction, long transactionId)
{
_innerConnection = innerConnection;
_transactionType = type;
if (null != outerTransaction)
{
_parent = new WeakReference(outerTransaction);
}
_transactionId = transactionId;
RestoreBrokenConnection = false;
ConnectionHasBeenRestored = false;
}
private XmlElementList(XmlNode parent)
{
Debug.Assert(parent != null);
Debug.Assert(parent.NodeType == XmlNodeType.Element || parent.NodeType == XmlNodeType.Document);
this.rootNode = parent;
Debug.Assert(parent.Document != null);
this.curInd = -1;
this.curElem = rootNode;
this.changeCount = 0;
this.empty = false;
this.atomized = true;
this.matchCount = -1;
// This can be a regular reference, but it would cause some kind of loop inside the GC
this.listener = new WeakReference(new XmlElementListListener(parent.Document, this));
}
// Tags a parent/collection as synchronized.
// Since we use a most-recently-used algorithm, it's useful
// to call this any time a collection is touched, even if it is
// only read.
internal static void MarkClean(DependencyObject parent, object collection)
{
lock (_cleanParentList)
{
int firstFreeIndex;
int index = GetCleanParentIndex(parent, collection, out firstFreeIndex);
if (index == -1)
{
index = firstFreeIndex >= 0 ? firstFreeIndex : _cleanParentList.Length - 1;
_cleanParentList[index] = new WeakReference(new ParentCollectionPair(parent, collection));
}
TouchCleanParent(index);
}
}
public WeakAction(object target, Action action)
{
if (action.Method.IsStatic)
{
_staticAction = action;
if (target != null)
Reference = new WeakReference(target);
return;
}
Method = action.Method;
ActionReference = new WeakReference(action.Target);
Reference = new WeakReference(target);
}
public static void Main(string[] args)
{
Console.WriteLine ("Memory: " + (GC.GetTotalMemory (true) / 1024) + " KB");
WeakReference wr;
{
// Generate the first string.
string text1 = "hello old world.";
for (int i = 0; i < 25; i++) {
text1 = text1 + text1;
}
wr = new WeakReference (text1);
// PRE GC CHECKS
// IF YOU UNCOMMENT THIS, GC WON'T COLLECT text1
if (!wr.IsAlive)
throw new Exception ("PRE GC - wr.IsAlive == false");
if (wr.Target == null)
throw new Exception ("PRE GC - wr.Target == null");
if (!(wr.Target is string))
throw new Exception ("PRE GC - wr.Target is not string");
text1 = null;
}
GC.Collect ();
GC.WaitForPendingFinalizers ();
Console.WriteLine ("Memory: " + (GC.GetTotalMemory (true) / 1024) + " KB");
// POST GC CHECKS
if (wr.IsAlive)
throw new Exception ("POST GC - wr.IsAlive == true");
if (wr.Target != null)
throw new Exception ("POST GC - wr.Target != null");
if ((wr.Target as string) != null)
throw new Exception ("POST GC - wr.Target as string != null");
// Generate the second string.
string text2 = "HELLO NEW WORLD!";
for (int i = 0; i < 25; i++) {
text2 = text2 + text2;
}
Console.WriteLine ("Memory: " + (GC.GetTotalMemory (true) / 1024) + " KB");
}
internal DataTableReaderListener(DataTableReader reader)
{
if (reader == null)
{
throw ExceptionBuilder.ArgumentNull(nameof(DataTableReader));
}
if (_currentDataTable != null)
{
UnSubscribeEvents();
}
_readerWeak = new WeakReference(reader);
_currentDataTable = reader.CurrentDataTable;
if (_currentDataTable != null)
{
SubscribeEvents();
}
}
public WeakEventListener(IEventListener listener)
{
_listenerRef = ServiceProvider.WeakReferenceFactory(listener, true);
}
public static T GetTarget <T>(this WeakReference <T> reference) where T : class
{
reference.TryGetTarget(out var target);
return(target);
}
/// <summary>
/// Initializes a new instance of the <see cref="WeakPropertyValue"/> class.
/// </summary>
/// <param name="name">The name of the property to override.</param>
/// <param name="value">The value to inject into the property.</param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
public WeakPropertyValue(string name, object value)
: base(name, (object)null, false)
{
this.weakReference = new WeakReference(value);
this.ValueCallback = (ctx, target) => this.weakReference.Target;
}
public WeakDelegate(object subscriber, object target, MethodInfo listener)
{
_subscriberReference = new WeakReference(subscriber ?? throw new ArgumentNullException(nameof(subscriber)));
_delegateSource = new MaybeWeakReference(subscriber, target ?? throw new ArgumentNullException(nameof(target)));
_listener = listener ?? throw new ArgumentNullException(nameof(listener));
}
protected override void Initialize()
{
_value = null;
_node.Subscribe(ValueChanged);
StartRoot();
}
private static ServicePoint FindServicePointHelper(Uri address, bool isProxyServicePoint)
{
GlobalLog.Enter("ServicePointManager::FindServicePointHelper() address:" + address.ToString());
if (isProxyServicePoint)
{
if (address.Scheme != Uri.UriSchemeHttp)
{
// <
Exception exception = new NotSupportedException(SR.GetString(SR.net_proxyschemenotsupported, address.Scheme));
GlobalLog.LeaveException("ServicePointManager::FindServicePointHelper() proxy has unsupported scheme:" + address.Scheme.ToString(), exception);
throw exception;
}
}
//
// Search for the correct proxy host,
// then match its acutal host by using ConnectionGroups
// which are located on the actual ServicePoint.
//
string tempEntry = MakeQueryString(address, isProxyServicePoint);
// lookup service point in the table
ServicePoint servicePoint = null;
GlobalLog.Print("ServicePointManager::FindServicePointHelper() locking and looking up tempEntry:[" + tempEntry.ToString() + "]");
lock (s_ServicePointTable) {
// once we grab the lock, check if it wasn't already added
WeakReference servicePointReference = s_ServicePointTable[tempEntry] as WeakReference;
GlobalLog.Print("ServicePointManager::FindServicePointHelper() lookup returned WeakReference#" + ValidationHelper.HashString(servicePointReference));
if (servicePointReference != null)
{
servicePoint = (ServicePoint)servicePointReference.Target;
GlobalLog.Print("ServicePointManager::FindServicePointHelper() successful lookup returned ServicePoint#" + ValidationHelper.HashString(servicePoint));
}
if (servicePoint == null)
{
// lookup failure or timeout, we need to create a new ServicePoint
if (s_MaxServicePoints <= 0 || s_ServicePointTable.Count < s_MaxServicePoints)
{
// Determine Connection Limit
int connectionLimit = InternalConnectionLimit;
string schemeHostPort = MakeQueryString(address);
bool userDefined = s_UserChangedLimit;
if (ConfigTable.ContainsKey(schemeHostPort))
{
connectionLimit = (int)ConfigTable[schemeHostPort];
userDefined = true;
}
servicePoint = new ServicePoint(address, s_ServicePointIdlingQueue, connectionLimit, tempEntry, userDefined, isProxyServicePoint);
GlobalLog.Print("ServicePointManager::FindServicePointHelper() created ServicePoint#" + ValidationHelper.HashString(servicePoint));
servicePointReference = new WeakReference(servicePoint);
s_ServicePointTable[tempEntry] = servicePointReference;
GlobalLog.Print("ServicePointManager::FindServicePointHelper() adding entry WeakReference#" + ValidationHelper.HashString(servicePointReference) + " key:[" + tempEntry + "]");
}
else
{
Exception exception = new InvalidOperationException(SR.GetString(SR.net_maxsrvpoints));
GlobalLog.LeaveException("ServicePointManager::FindServicePointHelper() reached the limit count:" + s_ServicePointTable.Count.ToString() + " limit:" + s_MaxServicePoints.ToString(), exception);
throw exception;
}
}
}
GlobalLog.Leave("ServicePointManager::FindServicePointHelper() servicePoint#" + ValidationHelper.HashString(servicePoint));
return(servicePoint);
}
// PropBag (Parent of PropItem) -- with old value.
private bool NotifyReceiver(IReceivePropStoreNodeUpdates_PropBag <T> propStoreUpdateReceiver, WeakRefKey <IPropBag> propItemParent, WeakReference <IPropBag> oldPropItemParent)
{
propStoreUpdateReceiver.OnPropStoreNodeUpdated(propItemParent, oldPropItemParent);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceEqualWeakReference"/> class.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="trackResurrection">if set to <c>true</c> [track resurrection].</param>
protected BaseWeakReference(object target, bool trackResurrection)
{
this.innerWeakReference = new WeakReference(target, trackResurrection);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceEqualWeakReference"/> class.
/// </summary>
/// <param name="target">The target.</param>
protected BaseWeakReference(object target)
{
this.innerWeakReference = new WeakReference(target);
}
public PropertyDescriptorFromItemPropertyBase(DataGridItemPropertyBase dataGridItemProperty)
: base(dataGridItemProperty.Name)
{
m_dataGridItemProperty = new WeakReference(dataGridItemProperty);
m_propertyType = dataGridItemProperty.DataType;
}
void DoReplace(int offset, int length, string newText, OffsetChangeMap offsetChangeMap)
{
if (length == 0 && newText.Length == 0)
{
return;
}
// trying to replace a single character in 'Normal' mode?
// for single characters, 'CharacterReplace' mode is equivalent, but more performant
// (we don't have to touch the anchorTree at all in 'CharacterReplace' mode)
if (length == 1 && newText.Length == 1 && offsetChangeMap == null)
{
offsetChangeMap = OffsetChangeMap.Empty;
}
string removedText = rope.ToString(offset, length);
DocumentChangeEventArgs args = new DocumentChangeEventArgs(offset, removedText, newText, offsetChangeMap);
// fire DocumentChanging event
if (Changing != null)
{
Changing(this, args);
}
undoStack.Push(this, args);
cachedText = null; // reset cache of complete document text
fireTextChanged = true;
DelayedEvents delayedEvents = new DelayedEvents();
lock (lockObject) {
// create linked list of checkpoints, if required
if (currentCheckpoint != null)
{
currentCheckpoint = currentCheckpoint.Append(args);
}
// now update the textBuffer and lineTree
if (offset == 0 && length == rope.Length)
{
// optimize replacing the whole document
rope.Clear();
rope.InsertText(0, newText);
lineManager.Rebuild();
}
else
{
rope.RemoveRange(offset, length);
lineManager.Remove(offset, length);
#if DEBUG
lineTree.CheckProperties();
#endif
rope.InsertText(offset, newText);
lineManager.Insert(offset, newText);
#if DEBUG
lineTree.CheckProperties();
#endif
}
}
// update text anchors
if (offsetChangeMap == null)
{
anchorTree.HandleTextChange(args.CreateSingleChangeMapEntry(), delayedEvents);
}
else
{
foreach (OffsetChangeMapEntry entry in offsetChangeMap)
{
anchorTree.HandleTextChange(entry, delayedEvents);
}
}
// raise delayed events after our data structures are consistent again
delayedEvents.RaiseEvents();
// fire DocumentChanged event
if (Changed != null)
{
Changed(this, args);
}
}
/// <summary>
/// Create a new UndoRoot to track undo / redo actions for a given instance / document.
/// </summary>
/// <param name="root">The "root" instance of the object hierarchy. All changesets will
/// need to passs a reference to this instance when they track changes.</param>
public UndoRoot(object root)
{
_root = new WeakReference(root);
_undoStack = new Stack <ChangeSet>();
_redoStack = new Stack <ChangeSet>();
}
public WeakCollectionChangedObservable(WeakReference <INotifyCollectionChanged> source)
{
_sourceReference = source;
}
public LeakSafeCompileEventRouter(ExampleEvaluatorByTimer module)
{
//Guard.ArgumentNotNull(module, "module");
this.weakControlRef = new WeakReference(module);
}
public NavigationDelegate(HtmlElement parent)
{
_parent = new WeakReference <HtmlElement>(parent);
}
public DocumentHandle(PdfDocument document)
{
_weakRef = new WeakReference(document);
ID = document._guid.ToString("B").ToUpper();
}
public CacheEntry(NativeObject cachedTarget)
{
_target = cachedTarget;
_targetWeak = new WeakReference <NativeObject>(cachedTarget);
LastAccess = Environment.TickCount;
}
private ParentObserver(View view)
{
_view = ServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(GetParent(view), Empty.WeakReference, false);
}
public SendToWeakThisEnvelope(object receiver)
{
_receiver = new WeakReference(receiver);
}
//
// FindServicePoint - Query using an Uri for a given server point
//
/// <devdoc>
/// <para>Findes an existing <see cref='System.Net.ServicePoint'/> or creates a new <see cref='System.Net.ServicePoint'/> to manage communications to the specified <see cref='System.Uri'/>
/// instance.</para>
/// </devdoc>
internal static ServicePoint FindServicePoint(string host, int port)
{
if (host == null)
{
throw new ArgumentNullException("address");
}
GlobalLog.Enter("ServicePointManager::FindServicePoint() host:" + host.ToString());
string tempEntry = null;
bool isProxyServicePoint = false;
//
// Search for the correct proxy host,
// then match its acutal host by using ConnectionGroups
// which are located on the actual ServicePoint.
//
tempEntry = "ByHost:" + host + ":" + port.ToString(CultureInfo.InvariantCulture);
// lookup service point in the table
ServicePoint servicePoint = null;
GlobalLog.Print("ServicePointManager::FindServicePoint() locking and looking up tempEntry:[" + tempEntry.ToString() + "]");
lock (s_ServicePointTable) {
// once we grab the lock, check if it wasn't already added
WeakReference servicePointReference = s_ServicePointTable[tempEntry] as WeakReference;
GlobalLog.Print("ServicePointManager::FindServicePoint() lookup returned WeakReference#" + ValidationHelper.HashString(servicePointReference));
if (servicePointReference != null)
{
servicePoint = (ServicePoint)servicePointReference.Target;
GlobalLog.Print("ServicePointManager::FindServicePoint() successfull lookup returned ServicePoint#" + ValidationHelper.HashString(servicePoint));
}
if (servicePoint == null)
{
// lookup failure or timeout, we need to create a new ServicePoint
if (s_MaxServicePoints <= 0 || s_ServicePointTable.Count < s_MaxServicePoints)
{
// Determine Connection Limit
int connectionLimit = InternalConnectionLimit;
bool userDefined = s_UserChangedLimit;
string schemeHostPort = host + ":" + port.ToString(CultureInfo.InvariantCulture);
if (ConfigTable.ContainsKey(schemeHostPort))
{
connectionLimit = (int)ConfigTable[schemeHostPort];
userDefined = true;
}
servicePoint = new ServicePoint(host, port, s_ServicePointIdlingQueue, connectionLimit, tempEntry, userDefined, isProxyServicePoint);
GlobalLog.Print("ServicePointManager::FindServicePoint() created ServicePoint#" + ValidationHelper.HashString(servicePoint));
servicePointReference = new WeakReference(servicePoint);
s_ServicePointTable[tempEntry] = servicePointReference;
GlobalLog.Print("ServicePointManager::FindServicePoint() adding entry WeakReference#" + ValidationHelper.HashString(servicePointReference) + " key:[" + tempEntry + "]");
}
else
{
Exception exception = new InvalidOperationException(SR.GetString(SR.net_maxsrvpoints));
GlobalLog.LeaveException("ServicePointManager::FindServicePoint() reached the limit count:" + s_ServicePointTable.Count.ToString() + " limit:" + s_MaxServicePoints.ToString(), exception);
throw exception;
}
}
}
GlobalLog.Leave("ServicePointManager::FindServicePoint() servicePoint#" + ValidationHelper.HashString(servicePoint));
return(servicePoint);
}
/// <summary>
/// Creates a new <see cref="GarbageCollectionTestSet"/> without instances to keep alive.
/// </summary>
/// <param name="weakReference"></param>
/// <param name="keepAliveInstances"></param>
public GarbageCollectionTestSet(WeakReference weakReference, object[] keepAliveInstances = null) : this(new[] { weakReference }, keepAliveInstances)
{
}
public AndroidWindow(ISurfaceHolder holder)
{
refHolder = new WeakReference(holder);
}
// To purge the collection corresponding to WeakReference for dead references
//
public void PurgeWeakRefCollection()
{
if (!(typeof(T).IsAssignableFrom(typeof(System.WeakReference))))
{
return;
}
List <object> cleanUpItemsCollection = new List <object>();
if (_usesHashCode)
{
if (_hashtable == null)
{
return;
}
foreach (KeyValuePair <object, T> dictionaryEntry in _hashtable)
{
WeakReference weakRef = dictionaryEntry.Value as WeakReference;
if (weakRef == null)
{
cleanUpItemsCollection.Add(dictionaryEntry.Key);
continue;
}
ElementProxy proxy = weakRef.Target as ElementProxy;
if (proxy == null)
{
cleanUpItemsCollection.Add(dictionaryEntry.Key);
continue;
}
ItemAutomationPeer peer = proxy.Peer as ItemAutomationPeer;
if (peer == null)
{
cleanUpItemsCollection.Add(dictionaryEntry.Key);
}
}
}
else
{
if (_list == null)
{
return;
}
foreach (KeyValuePair <object, T> keyValuePair in _list)
{
WeakReference weakRef = keyValuePair.Value as WeakReference;
if (weakRef == null)
{
cleanUpItemsCollection.Add(keyValuePair.Key);
continue;
}
ElementProxy proxy = weakRef.Target as ElementProxy;
if (proxy == null)
{
cleanUpItemsCollection.Add(keyValuePair.Key);
continue;
}
ItemAutomationPeer peer = proxy.Peer as ItemAutomationPeer;
if (peer == null)
{
cleanUpItemsCollection.Add(keyValuePair.Key);
}
}
}
foreach (object item in cleanUpItemsCollection)
{
Remove(item);
}
}
public void SetGitRepository(IGitRepository gitRepository)
{
_gitRepository = new WeakReference <IGitRepository>(gitRepository);
GitRepo = gitRepository;
}
WeakReference[] NavigatedEvent_NavigatedAwayEvent_Core()
{
TabControl target = new TabControl();
VM vm1 = new VM();
VM vm2 = new VM();
VM vm3 = new VM();
ViewInjectionManager.Default.Inject("region1", null, () => vm1);
ViewInjectionManager.Default.Inject("region1", null, () => vm2);
ViewInjectionManager.Default.Navigate("region1", vm2);
ViewInjectionService service = new ViewInjectionService()
{
RegionName = "region1"
};
Interaction.GetBehaviors(target).Add(service);
Window.Content = target;
EnqueueShowWindow();
EnqueueCallback(() => {
Assert.AreEqual(1, vm1.NavigatedCount);
Assert.AreEqual(1, vm1.NavigatedAwayCount);
Assert.AreEqual(1, vm2.NavigatedCount);
Assert.AreEqual(0, vm2.NavigatedAwayCount);
Assert.AreEqual(0, vm3.NavigatedCount);
Assert.AreEqual(0, vm3.NavigatedAwayCount);
ViewInjectionManager.Default.Navigate("region1", vm3);
ViewInjectionManager.Default.Inject("region1", null, () => vm3);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(1, vm1.NavigatedCount);
Assert.AreEqual(1, vm1.NavigatedAwayCount);
Assert.AreEqual(1, vm2.NavigatedCount);
Assert.AreEqual(1, vm2.NavigatedAwayCount);
Assert.AreEqual(1, vm3.NavigatedCount);
Assert.AreEqual(0, vm3.NavigatedAwayCount);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
target.SelectedItem = vm1;
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(2, vm1.NavigatedCount);
Assert.AreEqual(1, vm1.NavigatedAwayCount);
Assert.AreEqual(1, vm2.NavigatedCount);
Assert.AreEqual(1, vm2.NavigatedAwayCount);
Assert.AreEqual(1, vm3.NavigatedCount);
Assert.AreEqual(1, vm3.NavigatedAwayCount);
});
EnqueueTestComplete();
WeakReference targetReference = new WeakReference(target);
WeakReference serviceReference = new WeakReference(service);
WeakReference vm1Reference = new WeakReference(vm1);
WeakReference vm2Reference = new WeakReference(vm2);
WeakReference vm3Reference = new WeakReference(vm3);
Interaction.GetBehaviors(target).Remove(service);
Window.Content = null;
return(new WeakReference[] { targetReference, serviceReference, vm1Reference, vm2Reference, vm3Reference });
}
public ZoomboxViewStack(Zoombox zoombox)
{
_zoomboxRef = new WeakReference(zoombox);
}
/// <summary>
/// Indicates whether this <see cref="WeakReference{T}"/> is alive.
/// </summary>
/// <typeparam name="T">The type of the object.</typeparam>
/// <param name="self">The weak reference.</param>
/// <returns></returns>
public static bool IsAlive <T>(this WeakReference <T> self) where T : class
{
return(self?.GetOrDefault() != default(T));
}
WeakReference[] InjectRemove_Core()
{
Grid container = new Grid();
Window.Content = container;
object vm1 = null;
object vm2 = null;
object vm3 = null;
ViewInjectionManager.Default.Inject("region1", null, () => vm1 = new object(), "TestInjectionView1");
ViewInjectionManager.Default.Inject("region2", null, () => vm2 = new object());
ViewInjectionService service1 = new ViewInjectionService()
{
RegionName = "region1"
};
ContentPresenter target1 = new ContentPresenter();
container.Children.Add(target1);
Interactivity.Interaction.GetBehaviors(target1).Add(service1);
ViewInjectionService service2 = new ViewInjectionService()
{
RegionName = "region2"
};
ContentPresenter target2 = new ContentPresenter();
container.Children.Add(target2);
Interactivity.Interaction.GetBehaviors(target2).Add(service2);
Assert.IsNull(vm1);
Assert.IsNull(vm2);
Assert.IsNull(vm3);
EnqueueShowWindow();
EnqueueCallback(() => {
Assert.AreSame(vm1, target1.Content);
Assert.AreSame(vm2, target2.Content);
ViewInjectionManager.Default.Inject("region2", null, () => vm3 = new object(), typeof(TestInjectionView1));
Assert.AreSame(vm1, target1.Content);
Assert.AreSame(vm2, target2.Content);
ViewInjectionManager.Default.Navigate("region2", vm3);
Assert.AreSame(vm3, target2.Content);
Assert.AreEqual(2, ((IViewInjectionService)service2).ViewModels.Count());
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
ViewInjectionManager.Default.Remove("region1", vm1);
ViewInjectionManager.Default.Remove("region2", vm2);
ViewInjectionManager.Default.Remove("region2", vm3);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(0, ViewInjectionManager.Default.GetService("region1").ViewModels.Count());
Assert.AreEqual(0, ViewInjectionManager.Default.GetService("region2").ViewModels.Count());
});
EnqueueTestComplete();
WeakReference target1Reference = new WeakReference(target1);
WeakReference target2Reference = new WeakReference(target2);
WeakReference service1Reference = new WeakReference(service1);
WeakReference service2Reference = new WeakReference(service2);
WeakReference vm1Reference = new WeakReference(vm1);
WeakReference vm2Reference = new WeakReference(vm2);
WeakReference vm3Reference = new WeakReference(vm3);
Interaction.GetBehaviors(target1).Remove(service1);
Interaction.GetBehaviors(target2).Remove(service2);
Window.Content = null;
return(new WeakReference[] { target1Reference, target2Reference, service1Reference, service2Reference, vm1Reference, vm2Reference, vm3Reference });
}
public Key(MethodDef method)
{
this.method = new WeakReference(method);
this.hc = method.GetHashCode();
}
WeakReference[] PersistentMode_InjectRemove_Core(Func <object> vmFactory, object vm)
{
Grid container = new Grid();
Window.Content = container;
ViewInjectionManager.PersistentManager.Inject("region", null, vmFactory, typeof(TestInjectionView1));
ViewInjectionService service1 = new ViewInjectionService()
{
RegionName = "region", ViewInjectionManager = ViewInjectionManager.PersistentManager
};
ContentPresenter target1 = new ContentPresenter();
container.Children.Add(target1);
Interactivity.Interaction.GetBehaviors(target1).Add(service1);
ViewInjectionService service2 = new ViewInjectionService()
{
RegionName = "region", ViewInjectionManager = ViewInjectionManager.PersistentManager
};
ItemsControl target2 = new ItemsControl();
EnqueueShowWindow();
EnqueueCallback(() => {
Assert.AreSame(vm, target1.Content);
Assert.AreEqual(1, ((IViewInjectionService)service1).ViewModels.Count());
container.Children.Remove(target1);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(0, ((IViewInjectionService)service1).ViewModels.Count());
container.Children.Add(target1);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreSame(vm, target1.Content);
Assert.AreEqual(1, ((IViewInjectionService)service1).ViewModels.Count());
container.Children.Remove(target1);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Interactivity.Interaction.GetBehaviors(target2).Add(service2);
container.Children.Add(target2);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreSame(vm, target2.Items[0]);
Assert.AreEqual(0, ((IViewInjectionService)service1).ViewModels.Count());
Assert.AreEqual(1, ((IViewInjectionService)service2).ViewModels.Count());
Interaction.GetBehaviors(target1).Remove(service1);
Interaction.GetBehaviors(target2).Remove(service2);
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
service1.ViewInjectionManager = null;
service2.ViewInjectionManager = null;
Assert.AreEqual(0, ((IViewInjectionService)service1).ViewModels.Count());
Assert.AreEqual(0, ((IViewInjectionService)service2).ViewModels.Count());
});
EnqueueTestComplete();
WeakReference target1Reference = new WeakReference(target1);
WeakReference target2Reference = new WeakReference(target2);
WeakReference service1Reference = new WeakReference(service1);
WeakReference service2Reference = new WeakReference(service2);
return(new WeakReference[] { target1Reference, target2Reference, service1Reference, service2Reference });
}
