这DAL层实在不能让我理解

Question

public class Banji
{
       public int Id;
      public string Name;
}
public class Student{
    public int Id;
    public string Name;
    public int BaseBanJiId;
      public int banjiID;//只用记录班级的ID
}

Answer 1

我刚才也这么想来着 
但是 如果是班级呢  班级下面 有多个学生
如果SELECT * FROM 班级表 这根本带不出来所有的学生
直接联查 只能对应1对1的数据的时候

Answer 2

这个时候就是sql级联查询啊。一起把查询结果查出来啊

Answer 3

在根据学生提供的班级ID,从班级的DAL中去获取

Answer 4

R...两种方法 
1.用left join 班级，然后select 后
 Student xxx=new  Student()
  xx.BanJi=new Banji()
 xxx.Banji.ID=xxx
  xxx.Banji.Name=xxx2.班级一般是固定数据，而且也不多，那就 一次全读取出来，到全局缓存里
然后你select 学生就不要left了
foreach(var item in datatable.Rows)
 {
             Student student = new Student();
            student.BanJI = 这里从缓存里取班级
} 3.不要被三卖劲给搞昏了头

Answer 5

班级和学生表inner join一次查出来就可以命名拼音加英语太乱

Answer 6

public class Banji
{
       public int Id;
      public string Name;      public virtual List<Student> Students{get; set;}
}
public class Student{
    public int Id;
    public string Name;
    public int BaseBanJiId;
    public BanJi BanJi;
}class BanJiDAL{
      public List<BanJi> GetBanJiById(int [] id);
}
class StudentDAL{
      public Student GetStudentById(int id);      public List<Student> GetStudentsByBanJi(int id);
}如果你没用.Net提供的Linq to XX 框架生成
自己实现的话就用Inner Join查询

Answer 7

你这个三层太死了吧.为什么学生都要一个DAL呢
我感觉是一个Model

Answer 8

谁告诉你直接联查只能一对一的
一对多也可以联查，使用Left join

Answer 9

学生类里只存班级ID，然后建一个组合的model,在查询的时候两个表联合查询即可一次读出学生信息和班级信息。

Answer 10

下面的代码仅仅是个说明性的示例，一个有效的缓存系统必须实现数据库同步机制，允许不同的缓存需求采用不同的缓存策略与内存数据结构        public interface key<valueType> where valueType : IEquatable<valueType>
        {
            valueType Key { get; }
        }
        public class cache<valueType> where valueType : class, key<int>
        {
            private System.Collections.Generic.Dictionary<int, valueType> values;
            public cache()
            {
                values = new System.Collections.Generic.Dictionary<int, valueType>();
                //导入数据
            }
            public valueType this[int id]
            {
                get
                {
                    valueType value;
                    return values.TryGetValue(id, out value) ? value : null;
                }
            }
        }
        public class Banji : key<int>
        {
            public int Id;
            public string Name;
            public int Key { get { return Id; } }
            public static Banji GetById(int id)
            {
                return idCache[id];
            }
            private static cache<Banji> idCache = new cache<Banji>();
        }
        public class Student
        {
            public int Id;
            public string Name;
            public int BaseBanJiId;
            public Banji banji
            {
                get { return Banji.GetById(BaseBanJiId); }
            }
        }

Answer 11

下面的代码仅仅是个说明性的示例，一个有效的缓存系统必须实现数据库同步机制，允许不同的缓存需求采用不同的缓存策略与内存数据结构        public interface key<valueType> where valueType : IEquatable<valueType>
        {
            valueType Key { get; }
        }
        public class cache<valueType> where valueType : class, key<int>
        {
            private System.Collections.Generic.Dictionary<int, valueType> values;
            public cache()
            {
                values = new System.Collections.Generic.Dictionary<int, valueType>();
                //导入数据
            }
            public valueType this[int id]
            {
                get
                {
                    valueType value;
                    return values.TryGetValue(id, out value) ? value : null;
                }
            }
        }
        public class Banji : key<int>
        {
            public int Id;
            public string Name;
            public int Key { get { return Id; } }
            public static Banji GetById(int id)
            {
                return idCache[id];
            }
            private static cache<Banji> idCache = new cache<Banji>();
        }
        public class Student
        {
            public int Id;
            public string Name;
            public int BaseBanJiId;
            public Banji banji
            {
                get { return Banji.GetById(BaseBanJiId); }
            }
        }缓存是不是有专门的类库 类似memcached这样的东西

Answer 12

是需要专门的类库。memcached还有点远。
hibernate之类的比较近，就是性能不够好，而且策略支持不够自由灵活。