private static void RestoreRightTree(Model.TreeNode current, TreeNodeContext db)
        {
            if (current == null)
            {
                return;
            }
            var childsOfCurrentNode = db.TreeNodes.Where(n => n.ParentID == current.NodeID);

            current.right = childsOfCurrentNode.SingleOrDefault(n => n.value >= current.value);
            if (childsOfCurrentNode.SingleOrDefault(n => n.value < current.value) != null)
            {
                current.left = childsOfCurrentNode.SingleOrDefault(n => n.value < current.value);
                RestoreLeftTree(current.left, db);
            }
            RestoreLeftTree(current.right, db);
        }
        public static BinaryTree RestoreTree()
        {
            BinaryTree tree = new BinaryTree();
            using (TreeNodeContext db = new TreeNodeContext())
            {
                if (!db.Database.Exists())
                {
                    db.Database.Create();
                    return tree;
                }
                var nodes = db.TreeNodes;
                tree.root = nodes.SingleOrDefault(node => node.ParentID == null);

                RestoreLeftTree(tree.root, db);
            }
            return tree;
        }
 private void RemoveFromDB(TreeNode node, bool needRightChild, TreeNode mostLeft = null)
 {
     using (TreeNodeContext db = new TreeNodeContext())
     {
         UpdateIDs(db, needRightChild, node, mostLeft);
         var nodeToRemove = db.TreeNodes.SingleOrDefault(n => n.NodeID == node.NodeID);
         if (nodeToRemove != null)
         {
             db.TreeNodes.Remove(nodeToRemove);
         }
         db.SaveChanges();
     }
 }
        private void UpdateIDs(TreeNodeContext db, bool needRightChild, TreeNode nodeToRemove, TreeNode mostLeft)
        {
            var firstChildOfRemovingNode = needRightChild ? db.TreeNodes.SingleOrDefault(node => node.ParentID == nodeToRemove.NodeID && node.value >= nodeToRemove.value) 
                                                          : db.TreeNodes.SingleOrDefault(node => node.ParentID == nodeToRemove.NodeID && node.value < nodeToRemove.value);

            var leftChild = needRightChild ? db.TreeNodes.SingleOrDefault(node => node.ParentID == nodeToRemove.NodeID && node.value < nodeToRemove.value) : null;

            if (firstChildOfRemovingNode != null)
            {
                if(mostLeft != null)
                {
                    var mostLeftInDB = db.TreeNodes.SingleOrDefault(node => node.NodeID == mostLeft.NodeID);
                    mostLeftInDB.ParentID = nodeToRemove.ParentID;
                    if (leftChild != null)
                    {
                        leftChild.ParentID = mostLeft.NodeID;
                    }
                    if(mostLeftInDB.NodeID == firstChildOfRemovingNode.NodeID)
                    {
                        db.SaveChanges();
                        return;
                    } 
                    firstChildOfRemovingNode.ParentID = mostLeftInDB.NodeID;
                    db.SaveChanges();
                    return;
                }
                firstChildOfRemovingNode.ParentID = nodeToRemove.ParentID;
                db.SaveChanges();
            }
        }
 private int AddInDB(TreeNode node)
 {
     using (TreeNodeContext db = new TreeNodeContext())
     {
         db.TreeNodes.Add(node);
         db.SaveChanges();
         return node.NodeID;
     }
 }