/// <summary>
/// 处理站点栏目树形
/// </summary>
/// <param name="parentId"></param>
/// <param name="treeHandler"></param>
public void HandleCategoryTree(int parentId, CategoryTreeHandler treeHandler)
{
ICategory root = this.RootCategory;
int level = 0;
ItrCategoryTree(root, level, true, treeHandler);
}
/// <summary>
/// 处理站点栏目树形
/// </summary>
/// <param name="parentId"></param>
/// <param name="treeHandler"></param>
public void HandleCategoryTree(int parentId, CategoryTreeHandler treeHandler)
{
var root = RootCategory;
var level = 0;
ItrCategoryTree(root, level, true, treeHandler);
}
/// <summary>
/// 按栏目列表生成树,list[0]默认为根节点
/// </summary>
/// <param name="list"></param>
/// <param name="func"></param>
public void HandleCategoryTree(IEnumerable <Category> list, CategoryTreeHandler func)
{
int rootLft,
rootRgt;
IList <int> arr = new List <int>();
// 获得root节点的左边和右边的值
Category root = new List <Category>(list)[0];
if (root == null)
{
return;
}
rootLft = root.Lft;
rootRgt = root.Rgt;
//获取root节点的所有子节点
var childNodes = list.Where(a => a.Lft > rootLft && a.Rgt < rootRgt);
/* SELECT * FROM tree WHERE lft BETWEEN @rootLft AND @rootRgt ORDER BY lft ASC'); */
foreach (Category c in childNodes)
{
if (arr.Count > 0)
{
//判断最后一个值是否小于
int i;
while ((i = arr[arr.Count - 1]) < c.Rgt)
{
arr.Remove(i);
}
}
//树的层级= 列表arr的数量
func(c, arr.Count);
arr.Clear();
foreach (Category tc in childNodes)
{
arr.Add(tc.Rgt);
}
}
}
private void ItrCategoryTree(ICategory root, int level, bool isLast, CategoryTreeHandler handler)
{
if (root.GetDomainId() != 0)
{
handler(root, level, isLast);
}
IEnumerable <ICategory> list = root.NextLevelChilds.OrderBy(a => a.Get().SortNumber);
int len = list.Count();
if (len > 0)
{
int i = 0;
foreach (ICategory c in list)
{
this.ItrCategoryTree(c, level + 1, i++ == len, handler);
}
}
}
public void HandleCategoryTree(int siteId, int lft, CategoryTreeHandler treeHandler)
{
ISite site = this._resp.GetSiteById(siteId);
site.HandleCategoryTree(lft, treeHandler);
}
public void HandleCategoryTree(int siteId, int lft,CategoryTreeHandler treeHandler)
{
ISite site = this._resp.GetSiteById(siteId);
site.HandleCategoryTree(lft, treeHandler);
}
public void HandleCategoryTree(int siteId, int parentId, CategoryTreeHandler treeHandler)
{
ISite site = this.repo.GetSiteById(siteId);
site.HandleCategoryTree(parentId, treeHandler);
}
/// <summary>
/// 迭代遍历栏目及子栏目
/// </summary>
/// <param name="category"></param>
/// <param name="func"></param>
public void HandleCategoryTree(string categoryName, CategoryTreeHandler func)
{
/*
* 好吧，现在整个树都在一个查询中了。现在就要像前面的递归函数那样显示这个树，
* 我们要加入一个ORDER BY子句在这个查询中。如果你从表中添加和删除行，你的表可能就顺序不对了，
* 我们因此需要按照他们的左值来进行排序。
*
* SELECT * FROM tree WHERE lft BETWEEN 2 AND 11 ORDER BY lft ASC;
*
* 就只剩下缩进的问题了。要显示树状结构，子节点应该比他们的父节点稍微缩进一些。
* 我们可以通过保存一个右值的一个栈。每次你从一个节点的子节点开始时，
* 你把这个节点的右值 添加到栈中。你也知道子节点的右值都比父节点的右值小，
* 这样通过比较当前节点和栈中的前一个节点的右值，你可以判断你是不是在
* 显示这个父节点的子节点。当你显示完这个节点，你就要把他的右值从栈中删除。
* 要获得当前节点的层数，只要数一下栈中的元素。
*
*
*/
int rootLft,
rootRgt;
IList <int> arr = new List <int>();
// 获得root节点的左边和右边的值
Category root = this.Get(a => a.Name == categoryName);
if (root == null)
{
return;
}
rootLft = root.Lft;
rootRgt = root.Rgt;
//获取root节点的所有子节点
var childNodes = this.GetCategories(a => a.Lft > rootLft && a.Lft < rootRgt).OrderBy(a => a.Lft);
/* SELECT * FROM tree WHERE lft BETWEEN @rootLft AND @rootRgt ORDER BY lft ASC'); */
foreach (Category c in childNodes)
{
if (arr.Count > 0)
{
//判断最后一个值是否小于
int i;
while ((i = arr[arr.Count - 1]) < c.Rgt)
{
arr.Remove(i);
if (arr.Count == 0)
{
break;
}
}
}
//树的层级= 列表arr的数量
func(c, arr.Count);
//把所有栏目的右值,再加入到列表中
arr.Add(c.Rgt);
}
// int right = left + 1;
//func(category);
// foreach (Category c in this.GetCategories(a => a.PID == category.ID))
// {
// Foreach(c, func);
// }
}
public void HandleCategoryTree(int lft, CategoryTreeHandler treeHandler)
{
/*
* 好吧，现在整个树都在一个查询中了。现在就要像前面的递归函数那样显示这个树，
* 我们要加入一个ORDER BY子句在这个查询中。如果你从表中添加和删除行，你的表可能就顺序不对了，
* 我们因此需要按照他们的左值来进行排序。
*
* SELECT * FROM tree WHERE lft BETWEEN 2 AND 11 ORDER BY lft ASC;
*
* 就只剩下缩进的问题了。要显示树状结构，子节点应该比他们的父节点稍微缩进一些。
* 我们可以通过保存一个右值的一个栈。每次你从一个节点的子节点开始时，
* 你把这个节点的右值 添加到栈中。你也知道子节点的右值都比父节点的右值小，
* 这样通过比较当前节点和栈中的前一个节点的右值，你可以判断你是不是在
* 显示这个父节点的子节点。当你显示完这个节点，你就要把他的右值从栈中删除。
* 要获得当前节点的层数，只要数一下栈中的元素。
*
*
*/
IList <int> arr = new List <int>();
// 获得root节点的左边和右边的值
ICategory root = this.GetCategoryByLft(lft);
if (root == null)
{
throw new Exception("栏目不存在!");
}
var rootLft = root.Lft;
var rootRgt = root.Rgt;
//获取root节点的所有子节点
IEnumerable <ICategory> childNodes = this.GetCategories(root.Lft, root.Rgt, CategoryContainerOption.Childs);
/* SELECT * FROM tree WHERE lft BETWEEN @rootLft AND @rootRgt ORDER BY lft ASC'); */
int tmpInt = 0;
var categories = childNodes as ICategory[] ?? childNodes.ToArray();
int totalInt = categories.Count();
foreach (ICategory c in categories)
{
if (arr.Count > 0)
{
//判断最后一个值是否小于
int i;
while ((i = arr[arr.Count - 1]) < c.Rgt)
{
arr.Remove(i);
if (arr.Count == 0)
{
break;
}
}
}
//树的层级= 列表arr的数量
treeHandler(c, arr.Count, ++tmpInt == totalInt);
//把所有栏目的右值,再加入到列表中
arr.Add(c.Rgt);
}
// int right = left + 1;
//func(category);
// foreach (Category c in this.GetCategories(a => a.PID == category.ID))
// {
// Foreach(c, func);
// }
}
public void HandleCategoryTree(int lft, CategoryTreeHandler treeHandler)
{
/*
* 好吧，现在整个树都在一个查询中了。现在就要像前面的递归函数那样显示这个树，
* 我们要加入一个ORDER BY子句在这个查询中。如果你从表中添加和删除行，你的表可能就顺序不对了，
* 我们因此需要按照他们的左值来进行排序。
*
* SELECT * FROM tree WHERE lft BETWEEN 2 AND 11 ORDER BY lft ASC;
*
* 就只剩下缩进的问题了。要显示树状结构，子节点应该比他们的父节点稍微缩进一些。
* 我们可以通过保存一个右值的一个栈。每次你从一个节点的子节点开始时，
* 你把这个节点的右值 添加到栈中。你也知道子节点的右值都比父节点的右值小，
* 这样通过比较当前节点和栈中的前一个节点的右值，你可以判断你是不是在
* 显示这个父节点的子节点。当你显示完这个节点，你就要把他的右值从栈中删除。
* 要获得当前节点的层数，只要数一下栈中的元素。
*
*
*/
int rootLft,
rootRgt;
IList<int> arr = new List<int>();
// 获得root节点的左边和右边的值
ICategory root = this.GetCategoryByLft(lft);
if (root == null)
throw new Exception("栏目不存在!");
rootLft = root.Lft;
rootRgt = root.Rgt;
//获取root节点的所有子节点
IEnumerable<ICategory> childNodes =this.GetCategories(root.Lft, root.Rgt, CategoryContainerOption.Childs);
/* SELECT * FROM tree WHERE lft BETWEEN @rootLft AND @rootRgt ORDER BY lft ASC'); */
foreach (ICategory c in childNodes)
{
if (arr.Count > 0)
{
//判断最后一个值是否小于
int i;
while ((i = arr[arr.Count - 1]) < c.Rgt)
{
arr.Remove(i);
if (arr.Count == 0) break;
}
}
//树的层级= 列表arr的数量
treeHandler(c, arr.Count);
//把所有栏目的右值,再加入到列表中
arr.Add(c.Rgt);
}
// int right = left + 1;
//func(category);
// foreach (Category c in this.GetCategories(a => a.PID == category.ID))
// {
// Foreach(c, func);
// }
}
/// <summary>
/// 按栏目列表生成树,list[0]默认为根节点
/// </summary>
/// <param name="list"></param>
/// <param name="func"></param>
public void HandleCategoryTree(IEnumerable<Category> list, CategoryTreeHandler func)
{
int rootLft,
rootRgt;
IList<int> arr = new List<int>();
// 获得root节点的左边和右边的值
Category root =new List<Category>(list)[0];
if (root == null) return;
rootLft = root.Lft;
rootRgt = root.Rgt;
//获取root节点的所有子节点
var childNodes = list.Where(a => a.Lft > rootLft && a.Rgt < rootRgt);
/* SELECT * FROM tree WHERE lft BETWEEN @rootLft AND @rootRgt ORDER BY lft ASC'); */
foreach (Category c in childNodes)
{
if (arr.Count > 0)
{
//判断最后一个值是否小于
int i;
while ((i=arr[arr.Count-1])< c.Rgt)
{
arr.Remove(i);
}
}
//树的层级= 列表arr的数量
func(c, arr.Count);
arr.Clear();
foreach (Category tc in childNodes)
{
arr.Add(tc.Rgt);
}
}
}
