这个是源码
-------------------------- 基本数据接口-------------------
namespace XPDataAccess
{
/// <summary>
/// 关键字接口
/// </summary>
public interface IParmaryKey<P>
{
/// <summary>
/// 关键字
/// </summary>
P PrimaryKey
{
get ;
}
}
/// <summary>
/// 显示注册状态的参数
/// </summary>
public enum RegisterRelationStatus
{
/// <summary>
/// 注册成功
/// </summary>
RegistorOk,
/// <summary>
/// 关系已经存在
/// </summary>
RelationExist,
/// <summary>
/// 第一个主键不存在
/// </summary>
FirstKeyNotFound,
/// <summary>
/// 第二个主键不存在
/// </summary>
SecondKeyNotFound
}
/// <summary>
/// 关系管理器注册事件参数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
public class RegisterEventArgs<T, U> : EventArgs
{
private T _t;
private U _u;
private RegisterRelationStatus _st;
public RegisterEventArgs(T t, U u,RegisterRelationStatus st)
{
_t = t;
_u = u;
_st =st ;
}
public T First
{
get { return _t; }
}
public U Second
{
get { return _u; }
}
public RegisterRelationStatus RegisterStatus
{
get { return _st ;}
}
}
//数据库关系管理的基类,1:1,1:M,M:N的关系的管理均从此类继承.
public abstract class Relation<T,U,Tp,Up> where T:class ,IParmaryKey<Tp> where U:class ,IParmaryKey<Up>
{
protected Relation()
{
}
#region IRelation<T,U> Members
public event EventHandler<RegisterEventArgs<T, U>> Registered;
public event EventHandler<RegisterEventArgs<T, U>> UnRegistered;
public void Register(T t, U u)
{
RegisterRelationStatus status = AddRelation(t.PrimaryKey, u.PrimaryKey);
OnRegistered(new RegisterEventArgs<T, U>(t, u, status));
}
public void UnRegister(T t, U u)
{
RegisterRelationStatus status = RemoveRelation(t.PrimaryKey, u.PrimaryKey);
OnUnRegistered(new RegisterEventArgs<T, U>(t, u, status));
}
#endregion
protected virtual void OnRegistered(RegisterEventArgs<T, U> e)
{
if (Registered != null)
{
Registered(this, e);
}
}
protected virtual void OnUnRegistered(RegisterEventArgs<T, U> e)
{
if (UnRegistered != null)
{
UnRegistered(this, e);
}
}
protected abstract RegisterRelationStatus AddRelation(Tp t, Up u);
protected abstract RegisterRelationStatus RemoveRelation(Tp t, Up u);
public abstract T FindT(Tp tp) ;
public abstract U FindU(Up key) ;
}
/// <summary>
/// 一对一关系的相互映射接口
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
/// <typeparam name="Tp"></typeparam>
/// <typeparam name="Up"></typeparam>
public interface IOneToOne<T,U,Tp,Up> where T:class ,IParmaryKey<Tp> where U:class ,IParmaryKey<Up>
{
T FindOtherOne(U u);
U FindOtherOne(T t);
}
/// <summary>
/// 一对一关系的管理基类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
/// <typeparam name="Tp"></typeparam>
/// <typeparam name="Up"></typeparam>
public abstract class OneToOneRelation<T, U, Tp, Up> : Relation<T, U, Tp, Up>,IOneToOne<T,U,Tp,Up>
where T : class, IParmaryKey<Tp>
where U : class, IParmaryKey<Up>
{
protected abstract override RegisterRelationStatus AddRelation(Tp t, Up u);
protected abstract override RegisterRelationStatus RemoveRelation(Tp t, Up u);
public abstract override T FindT(Tp tp);
public abstract override U FindU(Up key);
#region IOneToOne<T,U,Tp,Up> Members
public abstract T FindOtherOne(U u);
public abstract U FindOtherOne(T t);
#endregion
}
/// <summary>
/// 宪法
/// </summary>
public class Law : IParmaryKey<int>
{
public Law()
{
}
private int _lowId;
private string _author;
/// <summary>
/// 宪法的起草人
/// </summary>
public string Author
{
get { return _author; }
set { _author = value; }
}
#region IParmaryKey<int> Members
public int PrimaryKey
{
get { return _lowId; }
set { _lowId = value; }
}
#endregion
}
/// <summary>
/// 国家
/// </summary>
public class Country : IParmaryKey<int>
{
public Country()
{
}
private int _cid;
private string _name;
private DateTime _jgTime;
public DateTime Gen
{
get { return _jgTime; }
set { _jgTime = value; }
}
public string Name
{
get { return _name; }
set { _name = value; }
}
#region IParmaryKey<int> Members
public int PrimaryKey
{
get { return _cid; }
set { _cid = value; }
}
#endregion
}
//1:1关系的用例.
public class CountryLaw : OneToOneRelation<Country, Law, int, int>
{
protected override RegisterRelationStatus AddRelation(int t, int u)
{
throw new Exception("The method or operation is not implemented.");
}
protected override RegisterRelationStatus RemoveRelation(int t, int u)
{
throw new Exception("The method or operation is not implemented.");
}
public override Country FindT(int tp)
{
throw new Exception("The method or operation is not implemented.");
}
public override Law FindU(int key)
{
throw new Exception("The method or operation is not implemented.");
}
public override Country FindOtherOne(Law u)
{
throw new Exception("The method or operation is not implemented.");
}
public override Law FindOtherOne(Country t)
{
throw new Exception("The method or operation is not implemented.");
}
}
///1:M关系/
public interface IOneToMany<T,U,Tp,Up> where T:class ,IParmaryKey<Tp> where U:class ,IParmaryKey<Up>
{
T Parent(U u);
U[] Subs(T u);
}
/// <summary>
/// 一对多关系管理的基类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
/// <typeparam name="Tp"></typeparam>
/// <typeparam name="Up"></typeparam>
public abstract class OneToManyRelation<T, U, Tp, Up> : Relation<T, U, Tp, Up>, IOneToMany<T, U, Tp, Up>
where T : class, IParmaryKey<Tp>
where U : class, IParmaryKey<Up>
{
protected abstract override RegisterRelationStatus AddRelation(Tp t, Up u);
protected abstract override RegisterRelationStatus RemoveRelation(Tp t, Up u);
public abstract override T FindT(Tp tp);
public abstract override U FindU(Up key);
#region IOneToMany<T,U,Tp,Up> Members
public abstract T Parent(U u);
public abstract U[] Subs(T u);
#endregion
}
/// <summary>
/// 学校
/// </summary>
public class School:IParmaryKey<Int32>
{
public School()
{
}
private int _sid;
private string _sn;
private string _addr;
public string SchoolName
{
get { return _sn; }
set { _sn = value; }
}
public string SchoolAddress
{
get { return _addr; }
set { _addr = value; }
}
#region IParmaryKey<int> Members
public int PrimaryKey
{
get { return _sid; }
set { _sid = value; }
}
#endregion
}
/// <summary>
/// 老师
/// </summary>
public class Teacher : IParmaryKey<Guid>
{
private string _tn;
private Guid _uid;
public Teacher()
{
}
public string TeacherName
{
get { return _tn; }
set { _tn = value; }
}
#region IParmaryKey<Guid> Members
public Guid PrimaryKey
{
get { return _uid; }
set { _uid = value; }
}
#endregion
}
public class SchoolTeacher : OneToManyRelation<School, Teacher, int, Guid>
{
protected override RegisterRelationStatus AddRelation(int t, Guid u)
{
throw new Exception("The method or operation is not implemented.");
}
protected override RegisterRelationStatus RemoveRelation(int t, Guid u)
{
throw new Exception("The method or operation is not implemented.");
}
public override School FindT(int tp)
{
throw new Exception("The method or operation is not implemented.");
}
public override Teacher FindU(Guid key)
{
throw new Exception("The method or operation is not implemented.");
}
public override School Parent(Teacher u)
{
throw new Exception("The method or operation is not implemented.");
}
public override Teacher[] Subs(School u)
{
throw new Exception("The method or operation is not implemented.");
}
}
M:N关系///
/// <summary>
/// 多对多关系的接口
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
/// <typeparam name="Tp"></typeparam>
/// <typeparam name="Up"></typeparam>
public interface IManyToMany<T, U, Tp, Up>
where T : class, IParmaryKey<Tp>
where U : class, IParmaryKey<Up>
{
T[] Subs(U u);
U[] Subs(T u);
}
/// <summary>
/// 多对多关系管理的基类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="U"></typeparam>
/// <typeparam name="Tp"></typeparam>
/// <typeparam name="Up"></typeparam>
public abstract class ManyToManyRelation<T, U, Tp, Up> : Relation<T, U, Tp, Up>, IManyToMany<T, U, Tp, Up>
where T : class, IParmaryKey<Tp>
where U : class, IParmaryKey<Up>
{
protected abstract override RegisterRelationStatus AddRelation(Tp t, Up u);
protected abstract override RegisterRelationStatus RemoveRelation(Tp t, Up u);
public abstract override T FindT(Tp tp);
public abstract override U FindU(Up key);
#region IManyToMany<T,U,Tp,Up> Members
public abstract T[] Subs(U u);
public abstract U[] Subs(T u);
#endregion
}
public class User : IParmaryKey<Guid>
{
private string _rn;
private string _app;
private Guid _rid;
public string UserName
{
get { return _rn; }
set { _rn = value; }
}
public string RealName
{
get { return _app; }
set { _app = value; }
}
#region IParmaryKey<Guid> Members
public Guid PrimaryKey
{
get { return _rid; }
set { _rid = value; }
}
#endregion
}
public class Roles : IParmaryKey<Guid>
{
public Roles()
{
}
private string _rn;
private string _app;
private Guid _rid;
public string RoleName
{
get { return _rn; }
set { _rn = value; }
}
public string Description
{
get { return _app; }
set { _app = value; }
}
#region IParmaryKey<Guid> Members
public Guid PrimaryKey
{
get { return _rid; }
set { _rid = value; }
}
#endregion
}
public class UserRoles : ManyToManyRelation<User, Roles, Guid, Guid>
{
protected override RegisterRelationStatus AddRelation(Guid t, Guid u)
{
throw new Exception("The method or operation is not implemented.");
}
protected override RegisterRelationStatus RemoveRelation(Guid t, Guid u)
{
throw new Exception("The method or operation is not implemented.");
}
public override User FindT(Guid tp)
{
throw new Exception("The method or operation is not implemented.");
}
public override Roles FindU(Guid key)
{
throw new Exception("The method or operation is not implemented.");
}
public override User[] Subs(Roles u)
{
throw new Exception("The method or operation is not implemented.");
}
public override Roles[] Subs(User u)
{
throw new Exception("The method or operation is not implemented.");
}
}
}
----------------------------------------------以后就是基于1:1,1:M,M:N三种基本的数据关系的展示和用例.
在应用到www.studyez.com的DAL层与BL层的开发上面,结合 ObjectDataSourse控件及 通用的分页解决方案 ,取得比较好的效果