public static void AddFiles(FileStore store, IEnumerable<WeakReference> items)
 {
     var storeRef = new WeakReference(store);
       foreach (var i in items) {
     queue.Add(new Item(storeRef, i));
       }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="WeakActionBase"/> class.
 /// </summary>
 /// <param name="target">The target of the weak action.</param>
 /// <exception cref="ArgumentException">The <paramref name="target"/> is <c>null</c> or whitespace.</exception>
 protected WeakActionBase(object target)
 {
     if (target != null)
     {
         _weakTarget = new WeakReference(target);
     }
 }

        // Calls to Add must be synchronized.
        public void Add(object key, object value)
        {
            Fx.Assert(key != null, "HopperCache key cannot be null.");
            Fx.Assert(value != null, "HopperCache value cannot be null.");

            // Special-case DBNull since it can never be collected.
            if (this.weak && !object.ReferenceEquals(value, DBNull.Value))
            {
                value = new WeakReference(value);
            }

            Fx.Assert(this.strongHopper.Count <= this.hopperSize * 2,
                "HopperCache strongHopper is bigger than it's allowed to get.");

            if (this.strongHopper.Count >= this.hopperSize * 2)
            {
                Hashtable recycled = this.limitedHopper;
                recycled.Clear();
                recycled.Add(key, value);

                // The try/finally is here to make sure these happen without interruption.
                try { } finally
                {
                    this.limitedHopper = this.strongHopper;
                    this.strongHopper = recycled;
                }
            }
            else
            {
                // We do nothing to prevent things from getting added multiple times.  Also may be writing over
                // a dead weak entry.
                this.strongHopper[key] = value;
            }
        }

            public void CreateAndDisposeExplicitSetting(ReferenceHandling referenceHandling)
            {
                var x = new WithSimpleProperties { Value = 1, Time = DateTime.MinValue };
                var y = new WithSimpleProperties { Value = 1, Time = DateTime.MinValue };
                var propertyChanges = new List<string>();
                var expectedChanges = new List<string>();

                using (var tracker = Track.IsDirty(x, y, PropertiesSettings.GetOrCreate(referenceHandling)))
                {
                    tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName);
                    Assert.AreEqual(false, tracker.IsDirty);
                    Assert.AreEqual(null, tracker.Diff);
                    CollectionAssert.IsEmpty(propertyChanges);

                    x.Value++;
                    Assert.AreEqual(true, tracker.IsDirty);
                    Assert.AreEqual("WithSimpleProperties Value x: 2 y: 1", tracker.Diff.ToString("", " "));
                    expectedChanges.AddRange(new[] { "Diff", "IsDirty" });
                    CollectionAssert.AreEqual(expectedChanges, propertyChanges);
                }

                x.Value++;
                CollectionAssert.AreEqual(expectedChanges, propertyChanges);

#if (!DEBUG) // debug build keeps instances alive longer for nicer debugging experience
                var wrx = new System.WeakReference(x);
                var wry = new System.WeakReference(y);
                x = null;
                y = null;
                System.GC.Collect();
                Assert.AreEqual(false, wrx.IsAlive);
                Assert.AreEqual(false, wry.IsAlive);
#endif
            }

        public void TestPublicNestedClassInternalNamedMethod()
        {
            Reset();

            const int index = 99;

            _itemPublic = new PublicNestedTestClass(index);
            _reference = new WeakReference(_itemPublic);

            _action = _itemPublic.GetAction(WeakActionTestCase.InternalNamedMethod);

            Assert.IsTrue(_reference.IsAlive);
            Assert.IsTrue(_action.IsAlive);

            _action.Execute();

            Assert.AreEqual(
                PublicNestedTestClass.Expected + PublicNestedTestClass.Internal + index,
                PublicNestedTestClass.Result);

            _itemPublic = null;
            GC.Collect();

#if SILVERLIGHT
            Assert.IsTrue(_reference.IsAlive); // Anonymous, private and internal methods cannot be GCed
            _action = null;
            GC.Collect();
            Assert.IsFalse(_reference.IsAlive);
#else
            Assert.IsFalse(_reference.IsAlive);
#endif
        }

 /// <summary>
 /// Constructor</summary>
 public TransactionPropertyNode(ITransactionContext context)
 {
     if(context != null)
         m_contextRef = new WeakReference(context);
     else
         IsReadOnly = true;
 }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
            var vm = (RepositoriesExploreViewModel)ViewModel;
            var search = (UISearchBar)TableView.TableHeaderView;

            TableView.RowHeight = UITableView.AutomaticDimension;
            TableView.EstimatedRowHeight = 64f;

            var weakVm = new WeakReference<RepositoriesExploreViewModel>(vm);
            BindCollection(vm.Repositories, repo =>
            {
                var description = vm.ShowRepositoryDescription ? repo.Description : string.Empty;
                var avatar = new GitHubAvatar(repo.Owner?.AvatarUrl);
                var sse = new RepositoryElement(repo.Name, repo.StargazersCount, repo.ForksCount, description, repo.Owner.Login, avatar) { ShowOwner = true };
                sse.Tapped += MakeCallback(weakVm, repo);
                return sse;
            });

            OnActivation(d =>
            {
                d(search.GetChangedObservable().Subscribe(x => vm.SearchText = x));
                d(vm.Bind(x => x.IsSearching).SubscribeStatus("Searching..."));
                d(search.GetSearchObservable().Subscribe(_ => {
                    search.ResignFirstResponder();
                    vm.SearchCommand.Execute(null);
                }));
            });
        }

        public static void ColumnsCollectionsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var grid = d as GridViewDataControl;
            if (grid == null)
            {
                return;
            }

            _grid = new WeakReference(grid);
            grid.Columns.Clear();
            grid.Unloaded += _grid_Unloaded;
            var collection = (ColumnCollection)e.NewValue;

            if (collection == null)
            {
                return;
            }

            _collection = new WeakReference(collection);

            if (collection.Any())
            {
                foreach (var column in collection)
                {
                    AddColumnToGrid(grid, column);
                }
            }

            collection.CollectionChanged -= _collection_CollectionChanged;
            collection.CollectionChanged += _collection_CollectionChanged;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectReference"/> class.
 /// </summary>
 /// <param name="creationTime">The creation time.</param>
 /// <param name="comObject">The com object to track.</param>
 /// <param name="stackTrace">The stack trace.</param>
 public ObjectReference(DateTime creationTime, ComObject comObject, string stackTrace)
 {
     CreationTime = creationTime;
     // Creates a long week reference to the ComObject
     Object = new WeakReference(comObject, true);
     StackTrace = stackTrace;
 }

        public CompressedStream(Stream baseStream)
        {
            this.baseStream = baseStream;
            localByte = new byte[1];
			cache = new MemoryStream();
            inBufferRef = new WeakReference(inBuffer, false);
        }

		/// <summary>
		/// Gets or sets cached data
		/// </summary>
		/// <value>The cached object or <c>null</c></value>
		public object this[object key]
		{
			get
			{
				var wr = _cache[key] as WeakReference;
				if (wr == null || !wr.IsAlive)
				{
					_cache.Remove(key);
					return null;
				}

				return wr.Target;
			}
			set
			{
				if (value == null)
				{
					_cache.Remove(key);
				}
				else
				{
					_cache[key] = new WeakReference(value);
				}
			}
		}

        /// <summary>
        /// Loads the image into given imageView using defined parameters.
        /// </summary>
        /// <param name="parameters">Parameters for loading the image.</param>
        /// <param name="imageView">Image view that should receive the image.</param>
        /// <param name="imageScale">Optional scale factor to use when interpreting the image data. If unspecified it will use the device scale (ie: Retina = 2, non retina = 1)</param>
        public static IScheduledWork Into(this TaskParameter parameters, UIImageView imageView, float imageScale = -1f)
        {
            var weakRef = new WeakReference<UIImageView>(imageView);
            Func<UIImageView> getNativeControl = () => {
                UIImageView refView;
                if (!weakRef.TryGetTarget(out refView))
                    return null;
                return refView;
            };

			Action<UIImage, bool> doWithImage = (img, fromCache) => {
                UIImageView refView = getNativeControl();
                if (refView == null)
                    return;

				var isFadeAnimationEnabled = parameters.FadeAnimationEnabled.HasValue ? 
					parameters.FadeAnimationEnabled.Value : ImageService.Config.FadeAnimationEnabled;

				if (isFadeAnimationEnabled && !fromCache)
				{
					// fade animation
					UIView.Transition(refView, 0.4f, 
						UIViewAnimationOptions.TransitionCrossDissolve 
						| UIViewAnimationOptions.BeginFromCurrentState,
						() => { refView.Image = img; },
						() => {  });
				}
				else
				{
					refView.Image = img;
				}
            };

            return parameters.Into(getNativeControl, doWithImage, imageScale);
        }

        static void Main()
        {
            // Instantiate a weak reference to MathTest object
             WeakReference mathReference = new WeakReference(new MathTest());
             MathTest math;
             if(mathReference.IsAlive)
             {
            math = mathReference.Target as MathTest;
            math.Value = 30;
            Console.WriteLine(
               "Value field of math variable contains " + math.Value);
            Console.WriteLine("Square of 30 is " + math.GetSquare());

             }
             else
             {
            Console.WriteLine("Reference is not available.");
             }

             GC.Collect();

             if(mathReference.IsAlive)
             {
            math = mathReference.Target as MathTest;
             }
             else
             {
            Console.WriteLine("Reference is not available.");
             }
        }

        public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected()
        {
            // Arrange
            var observer = new Observer();
            var model = new SomeModel(observer);
            Action<int> onChange = model.Change;
            var weakOnChange = new WeakReference(onChange);

            var counter = Reactive.Of(0);
            counter.PropertyChanged +=
                (sender, args) =>
                {
                    var handler = weakOnChange.Target as Action<int>;
                    if (handler != null)
                        handler(counter);
                };

            // Act
            onChange = null;
            GC.Collect();
            counter.Value = 1;

            // Assert
            observer.ChangedObserved.Should().BeFalse();
        }

        public void TestInternalNestedClassAnonymousStaticMethod()
        {
            Reset();

            _itemInternal = new InternalNestedTestClass();
            _reference = new WeakReference(_itemInternal);

            _action = _itemInternal.GetFunc(WeakActionTestCase.AnonymousStaticMethod);

            Assert.IsTrue(_reference.IsAlive);
            Assert.IsTrue(_action.IsAlive);

            string result = _action.Execute();

            Assert.AreEqual(
                InternalNestedTestClass.Expected,
                InternalNestedTestClass.Result);
            Assert.AreEqual(
                InternalNestedTestClass.Expected,
                result);

            _itemInternal = null;
            GC.Collect();

            Assert.IsFalse(_reference.IsAlive);
        }

        public static void UpdateBinding(object sender, DependencyPropertyChangedEventArgs args)
        {
            if (sender == null)
                return;

            span = new WeakReference(sender);
            ((Span)span.Target).Inlines.Clear();

            INotifyCollectionChanged newSource = args.NewValue as INotifyCollectionChanged;
            INotifyCollectionChanged oldSource = args.OldValue as INotifyCollectionChanged;

            if (oldSource != null)
                oldSource.CollectionChanged -= OnSourceCollectionChanged;

            if (newSource == null)
                return;

            // Detach our View from the ViewModel source
            //EDIT: Bug fix to reflect PB7's new UI model.
            newSource.CollectionChanged -= OnSourceCollectionChanged;

            IEnumerable ns = newSource as IEnumerable;
            OnSourceCollectionChanged(ns, null);
            newSource.CollectionChanged += OnSourceCollectionChanged;
        }

		public BaseTypeNodeImpl(ITreeNodeGroup treeNodeGroup, ITypeDefOrRef typeDefOrRef, bool isBaseType) {
			TreeNodeGroup = treeNodeGroup;
			this.isBaseType = isBaseType;
			// Keep weak refs to them so we won't prevent removed modules from being GC'd.
			weakRefTypeDefOrRef = new WeakReference(typeDefOrRef);
			weakRefResolvedTypeDef = new WeakReference(null);
		}

        public void TestPublicClassPublicStaticMethod()
        {
            Reset();

            _itemPublic = new PublicTestClass();
            _reference = new WeakReference(_itemPublic);

            _action = _itemPublic.GetFunc(WeakActionTestCase.PublicStaticMethod);

            Assert.IsTrue(_reference.IsAlive);
            Assert.IsTrue(_action.IsAlive);

            var result = _action.Execute();

            Assert.AreEqual(
                PublicTestClass.Expected + PublicTestClass.PublicStatic,
                PublicTestClass.Result);
            Assert.AreEqual(
                PublicTestClass.Expected + PublicTestClass.PublicStatic,
                result);

            _itemPublic = null;
            GC.Collect();

            Assert.IsFalse(_reference.IsAlive);
        }

        public ViewShowcaseStep(Activity activity, int viewId)
        {
            this.parentActivity = new WeakReference<Activity>(activity);
            this.viewId = viewId;

            Setup();
        }

        /// <summary>
        /// 重建模块缓存
        /// </summary>
        public static void RebuiltModule()
        {

            //释放资源
            module_ref = null;


            //重新赋值
            if (modules != null)
            {
                for (int i = 0; i < modules.Count; i++)
                {
                    modules.Remove(modules[i]);
                }
            }

            modules = dal.GetModules();

            //指定弱引用
            module_ref = new WeakReference(modules);

            if (OnModuleBuilting != null)
            {
                OnModuleBuilting();
            }

        }