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 }); }