Exemplo n.º 1
0
        public BuildTreeItemNode(NamedTypeBuildKey buildKey, Boolean nodeCreatedByContainer,
                                 BuildTreeItemNode parentNode)
        {
            Contract.Requires<ArgumentNullException>(buildKey != null);

            BuildKey = buildKey;
            NodeCreatedByContainer = nodeCreatedByContainer;
            Parent = parentNode;
            Children = new Collection<BuildTreeItemNode>();
        }
Exemplo n.º 2
0
        public BuildTreeItemNode(NamedTypeBuildKey buildKey, Boolean nodeCreatedByContainer,
                                 BuildTreeItemNode parentNode)
        {
            Contract.Requires <ArgumentNullException>(buildKey != null);

            BuildKey = buildKey;
            NodeCreatedByContainer = nodeCreatedByContainer;
            Parent   = parentNode;
            Children = new Collection <BuildTreeItemNode>();
        }
Exemplo n.º 3
0
        public override void PreBuildUp(IBuilderContext context)
        {
            base.PreBuildUp(context);

            bool nodeCreatedByContainer = context.Existing == null;
            var  newTreeNode            = new BuildTreeItemNode(context.BuildKey, nodeCreatedByContainer, _currentBuildNode);

            if (_currentBuildNode != null)
            {
                // This is a child node. Add it to the parent node.
                _currentBuildNode.Children.Add(newTreeNode);
            }

            _currentBuildNode = newTreeNode;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Called during the chain of responsibility for a teardown operation. The
        /// PostTearDown method is called when the chain has finished the PreTearDown
        /// phase and executes in reverse order from the PreTearDown calls.
        /// </summary>
        public override void PostTearDown(IBuilderContext context)
        {
            base.PostTearDown(context);

            lock (_lock)
            {
                BuildTreeItemNode buildTree = GetBuildTreeForInstance(context.Existing);
                if (buildTree != null)
                {
                    if (DecreaseTreeRefCount(context, buildTree))
                    {
                        _buildTrees.Remove(buildTree.ItemReference);
                    }
                }
            }

            RemoveDeadTrees(context);
        }
Exemplo n.º 5
0
        private void DisposeTree(BuildTreeItemNode buildTree)
        {
            foreach (BuildTreeItemNode child in buildTree.Children)
            {
                DisposeTree(child);
            }

            var disposable = buildTree.ItemReference.Target as IDisposable;

            if (disposable != null)
            {
                disposable.Dispose();
            }

            lock (_lock)
            {
                _buildTrees.Remove(buildTree.ItemReference);
            }
        }
Exemplo n.º 6
0
        private bool DecreaseTreeRefCount(IBuilderContext context, BuildTreeItemNode buildTree)
        {
            Contract.Requires(context != null);
            Contract.Requires(buildTree != null);

            bool removeBuildTree = false;

            foreach (BuildTreeItemNode child in buildTree.Children)
            {
                removeBuildTree |= DecreaseTreeRefCount(context, child);
            }

            var disposable = buildTree.ItemReference.Target as IDisposable;

            if (disposable == null)
            {
                return(removeBuildTree);
            }

            // Object is disposable, so we need to track the reference count
            int count;

            if (_refCounter.TryDecrement(disposable, out count) && count == 0)
            {
                DisposingLifetimeManager lifetimeManager = context.Lifetime.OfType <DisposingLifetimeManager>()
                                                           .SingleOrDefault(ltm => ltm.AppliesTo(disposable));

                if (lifetimeManager != null)
                {
                    disposable.Dispose();
                    lifetimeManager.RemoveValue(disposable);
                    removeBuildTree = true;
                }
            }

            return(removeBuildTree);
        }
Exemplo n.º 7
0
        public override void PostBuildUp(IBuilderContext context)
        {
            Contract.Requires(context != null);

            AssignInstanceToCurrentTreeNode(context.BuildKey, context.Existing);

            BuildTreeItemNode parentNode = _currentBuildNode.Parent;
            bool shouldTrackObject       = ShouldTrackObject(context);

            if (shouldTrackObject)
            {
                _refCounter.Increment(context.Existing);
            }
            else if (parentNode != null && _currentBuildNode.Children.Count == 0)
            {
                parentNode.Children.Remove(_currentBuildNode);
            }

            if (parentNode == null && (shouldTrackObject || _currentBuildNode.Children.Count > 0))
            {
                // This is the end of the creation of the root node
                lock (_lock)
                {
                    if (GetBuildTreeForInstance(context.Existing) == null)
                    {
                        _buildTrees.Add(_currentBuildNode.ItemReference, _currentBuildNode);
                    }
                }
            }

            // Move the current node back up to the parent
            // If this is the top level node, this will set the current node back to null
            _currentBuildNode = parentNode;

            base.PostBuildUp(context);
        }
        public override void PostBuildUp(IBuilderContext context)
        {
            Contract.Requires(context != null);

            AssignInstanceToCurrentTreeNode(context.BuildKey, context.Existing);

            BuildTreeItemNode parentNode = _currentBuildNode.Parent;
            bool shouldTrackObject = ShouldTrackObject(context);

            if (shouldTrackObject)
            {
                _refCounter.Increment(context.Existing);
            }
            else if (parentNode != null && _currentBuildNode.Children.Count == 0)
            {
                parentNode.Children.Remove(_currentBuildNode);
            }

            if (parentNode == null && (shouldTrackObject || _currentBuildNode.Children.Count > 0))
            {
                // This is the end of the creation of the root node
                lock (_lock)
                {
                    if (GetBuildTreeForInstance(context.Existing) == null)
                    {
                        _buildTrees.Add(_currentBuildNode.ItemReference, _currentBuildNode);
                    }
                }
            }

            // Move the current node back up to the parent
            // If this is the top level node, this will set the current node back to null
            _currentBuildNode = parentNode;

            base.PostBuildUp(context);
        }
        private void DisposeTree(BuildTreeItemNode buildTree)
        {
            foreach (BuildTreeItemNode child in buildTree.Children)
            {
                DisposeTree(child);
            }

            var disposable = buildTree.ItemReference.Target as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }

            lock (_lock)
            {
                _buildTrees.Remove(buildTree.ItemReference);
            }
        }
        private bool DecreaseTreeRefCount(IBuilderContext context, BuildTreeItemNode buildTree)
        {
            Contract.Requires(context != null);
            Contract.Requires(buildTree != null);

            bool removeBuildTree = false;

            foreach (BuildTreeItemNode child in buildTree.Children)
            {
                removeBuildTree |= DecreaseTreeRefCount(context, child);
            }

            var disposable = buildTree.ItemReference.Target as IDisposable;
            if (disposable == null)
                return removeBuildTree;

            // Object is disposable, so we need to track the reference count
            int count;
            if (_refCounter.TryDecrement(disposable, out count) && count == 0)
            {
                DisposingLifetimeManager lifetimeManager = context.Lifetime.OfType<DisposingLifetimeManager>()
                                                                  .SingleOrDefault(ltm => ltm.AppliesTo(disposable));

                if (lifetimeManager != null)
                {
                    disposable.Dispose();
                    lifetimeManager.RemoveValue(disposable);
                    removeBuildTree = true;
                }
            }

            return removeBuildTree;
        }
        public override void PreBuildUp(IBuilderContext context)
        {
            base.PreBuildUp(context);

            bool nodeCreatedByContainer = context.Existing == null;
            var newTreeNode = new BuildTreeItemNode(context.BuildKey, nodeCreatedByContainer, _currentBuildNode);

            if (_currentBuildNode != null)
            {
                // This is a child node. Add it to the parent node.
                _currentBuildNode.Children.Add(newTreeNode);
            }

            _currentBuildNode = newTreeNode;
        }