前两天的面试题

挺可惜的，也不可惜，只能怪自已抓不住。

只顾着争取机会了，却没有做好准备，曾在初中一年级的时候，数学老师出了一道题，同学们都争先恐后的举手去答，我也不例外，我得到了机会，可发现只顾去抢机会了，却没在意看题，结果很显然没有答出来，被老师狠狠的训了一通，多年后的今天，犯了同样的错误。怪不得别人，我这个人就是不长记性！！要懂得在失败中吸取教训，下次做事前先三思。

废话少说，先来看题:

大概题意：给一个树状结构设计一个表来存数据，只需存节点的名称，并用存储过程求出某一节点的所有子节点

解答：

表设计：

Guid(pk,uniqueidentifier,not null)唯一标识

Name(nvarchar(50),null)节点名称  

Code(nvarchar(200),null)节点代码

Layer(int ,null)节点所在层数

 

 

其中Code的存取方式为

 001                                                         002                                                      003

001，001             001，002                     002，001            002，002                  003，001            003，002

001，001，001    001，002，001            002，001，001   002，002，001         003，001，001   003，002，001

 

用存储过程找出指定结点的所有子节点

 

CREATE PROCEDURE [dbo].[test]
@code varchar(200)

as
select * from 表名 where Code like @code+',%';

这种应用，我在一年前就做过了，做过后就扔了，没常拿出来看看，真是可惜了。

下面把树的填充也贴出来。

填充树自然是用递归了。

建一个Model类(以下model类为实际工作代码，拿来展示)

[Serializable] public class Itm_TypeInfo { public Itm_TypeInfo() {} #region Model private Guid _guid; private string _name; private string _displayname; private int? _seriestype; private string _websitemark; private string _typecode; private int _layer; //分类所在的级别 public int Layer { get { return _layer; } set { _layer = value; } } //分类编号 public string TypeCode { get { return _typecode; } set { _typecode = value; } } /// <summary> /// GUID /// </summary> public Guid Guid { set{ _guid=value;} get{return _guid;} } /// <summary> /// 分类名（中文名） /// </summary> public string Name { set{ _name=value;} get{return _name;} } /// <summary> /// 分类显示名称（英文） /// </summary> public string DisplayName { set{ _displayname=value;} get{return _displayname;} } /// <summary> /// 所属系列 /// </summary> public int? SeriesType { set{ _seriestype=value;} get{return _seriestype;} } /// <summary> /// 所属网站 /// </summary> public string WebSiteMark { set{ _websitemark=value;} get{return _websitemark;} } #endregion Model /// <summary> /// 分类成员枚举 /// </summary> public enum Member { Guid, Name, DisplayName, SeriesType, WebSiteMark, TypeCode, Layer } }

 再建一个Entity类

 

 [Serializable ] public class TypeDetail:IOSS3 .Item .Model .Itm_TypeInfo { private IList<IOSS3.Item.Entity.TypeDetail> _TypeList;//子分类列表 public IList<IOSS3.Item.Entity.TypeDetail> TypeList { get { return _TypeList; } set { _TypeList = value; } } public TypeDetail(IOSS3 .Item .Model .Itm_TypeInfo type) { base.Guid = type.Guid; base.Layer = type.Layer; base.Name = type.Name; base.SeriesType = type.SeriesType; base.TypeCode = type.TypeCode; base.WebSiteMark = type.WebSiteMark; base.DisplayName = type.DisplayName; _TypeList = new List<IOSS3.Item.Entity.TypeDetail>(); } }

/// <summary> /// 获取分类及其下的子分类列表 /// </summary> /// <param name="args"></param> /// <returns></returns> public IList<IOSS3.Item.Entity.TypeDetail> GetTypeDetailList(IOSS3.Item.Arguments.TypeQueryArgs args) { if (args == null) return null; Hashtable where = new Hashtable(); if (args.Guid != null && args.Guid != Guid.Empty) where.Add(IOSS3.Item.Model.Itm_TypeInfo.Member.Guid, args.Guid); if (args.SeriesType != null && args.SeriesType != 0) where.Add(IOSS3.Item.Model.Itm_TypeInfo.Member.SeriesType, args.SeriesType); if (args.DisplayName != null && args.DisplayName.Length > 0) where.Add(IOSS3.Item.Model.Itm_TypeInfo.Member.DisplayName, "%" + args.DisplayName + "%"); if (args.WebSiteMark != null && args.WebSiteMark.Count > 0) where.Add(IOSS3.Item.Model.Itm_TypeInfo.Member.WebSiteMark, args.WebSiteMark); IList <IOSS3 .Item .Model .Itm_TypeInfo >typelist=DAL.Type.GetList(where); if (typelist == null || typelist.Count <= 0) return null; IList<IOSS3.Item.Entity.TypeDetail> typedetaillist = new List<IOSS3.Item.Entity.TypeDetail>(); FindChildType( typedetaillist,ref typelist); return typedetaillist; }

递归方法来填充Entity

/// <summary> /// /// 查询指定分类的子分类 /// </summary> /// <param name="typedetails"></param> /// <param name="typecode"></param> private void FindChildType( IList<IOSS3.Item.Entity .TypeDetail> typedetails, ref IList <IOSS3 .Item .Model .Itm_TypeInfo >types) { int j = 0; for (; j < types.Count; j++) { bool find = false; if (types.Count == 0) return; for (int i = 0; i < typedetails.Count; i++) { if (types.Count == 0) return; if (types[j].TypeCode.StartsWith(typedetails[i].TypeCode) && (types [j].Layer -typedetails [i].Layer ==1))//如果是当前分类的子分类则添加 { typedetails[i].TypeList.Add(new IOSS3.Item.Entity.TypeDetail(types[j])); types.RemoveAt(j); find = true; j--; IList <IOSS3 .Item .Entity .TypeDetail > Childlist=typedetails[i].TypeList; FindChildType( Childlist, ref types);//查找当前分类的子分类的子分类 } } if (!find) { if (types.Count == 0) return; if (types[j].Layer ==1&&(typedetails==null || typedetails.Count ==0|| typedetails [0].TypeCode .Length ==3))//如果是一级分类则添加到根目录 { if (types.Count == 0) return; typedetails.Add(new IOSS3.Item.Entity.TypeDetail(types[j])); types.RemoveAt(j); j--; FindChildType( typedetails, ref types); } } } }

递归填充树

// 绑定装备类别列表 private void BindTypeList() { tvTypeList.Nodes.Clear(); if (_TypeList == null || _TypeList.Count <= 0) return; TreeNode foot = new TreeNode(); foot.Expand(); foot.Text = ((TypeClass)this.cbxSearchST.SelectedItem).TypeName + "系列"; FillType(ref _TypeList, foot); tvTypeList.Nodes.Add(foot); } //填充树 private void FillType(ref IList<IOSS3.Item.Entity.TypeDetail> types, TreeNode foot) { this.tvTypeList.Nodes.Clear(); for (int i = 0; i < types.Count; i++) { TreeNode tn = new TreeNode(); tn.Name = types[i].Guid.ToString(); tn.Text = types[i].Name; tn.Tag = (IOSS3.Item.Entity.TypeDetail)types[i]; if (types[i].TypeList != null && types.Count > 0) { for (int j = 0; j < types[i].TypeList.Count; j++) { TreeNode tnchild = new TreeNode(); tnchild.Name = types[i].TypeList[j].Guid.ToString(); tnchild.Text = types[i].TypeList[j].Name; tnchild.Tag = types[i].TypeList[j]; tn.Nodes.Add(tnchild); if (types[i].TypeList[j].TypeList != null && types[i].TypeList[j].TypeList.Count > 0) { IList<IOSS3.Item.Entity.TypeDetail> typelist = types[i].TypeList[j].TypeList; FillType(ref typelist, tnchild); } } } foot.Nodes.Add(tn); } }

 ref关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。若要使用ref参数，则方法定义和调用方法都必须显式地使用ref关键字。
out关键字也是使参数按引用传递。这与ref关键字类似，不同之处在于ref要求变量必须在传递之前进行初始化。若要使用out参数，方法定义和调用方法都必须显式地使用out关键字。

 

下面这个网站电脑卖的好便宜，好奇怪

http://www.ckaism.com