Linq鉴别器列

鉴别器列其实就是相当于类的全类型名称

鉴别器列必须位于父类，而且父类不能是抽象类

 

看以下的例子：

User表结构

                 ID        Name      UserType      Publisher    Author      Type

 数据值                                                                                           CUser

1.     [Table(Name="User")]
2.     [InheritanceMapping(Code = "Unknown", Type = typeof(BaseUser), IsDefault = true)]
3.     [InheritanceMapping(Code = "CUser", Type = typeof(CUser))]
4.     public class BaseUser : IEntity
5.     {
6.         
8.         private System.Guid _ID;
9.         [Column(Storage = "_ID", Name = "ID", DbType = "UniqueIdentifier NOT NULL",
10.                 IsPrimaryKey = true, CanBeNull = false)]
11.         public System.Guid ID
12.         {
13.             get { return _ID; }
14.             set { _ID = value; }
15.         }
17.         [Column]
18.         public string Name
19.         {
20.             get;
21.             set;
22.         }
24.         /// <summary>
25.         /// 鉴别器
26.         /// </summary>
27.         [Column(IsDiscriminator = true, AutoSync = AutoSync.Never)]
28.         public string Type { get; set; }

1.  public class CUser : BaseUser
2.     {
3.         [Column]
4.         public char UserType
5.         {
6.             get;
7.             set;
8.         }
10.         [Column(Name = "Publisher")]
11.         public Guid PublisherID
12.         {
13.             get;
14.             set;
15.         }
17.         [Column(Name = "Author")]
18.         public Guid AuthorID
19.         {
20.             get;
21.             set;
22.         }
23.     }

可以看到 UserDataControl 数据控制类的部分代码

如果Type的值为空，以下代码返回值为 null，因此鉴别列非常重要，因为内核代码是通过鉴别列的值来确定返回什么类型的子类

1. var query = from user in theDataContext.GetTable<BaseUser>()
2.                             where user.ID == objIEntity.ID
3.                             select user as CUser; 

1. public override IEntity SelectByPK(Guid Key)
2.         {
3.             try
4.             {
5.                 CUser objCUser = new CUser();
7.                 var query = from user in theDataContext.GetTable<BaseUser>()
8.                             where user.ID == Key 
9.                             select new 
10.                             {
11.                                 ID = user.ID,
12.                                 UserType = ((CUser)user).UserType,
13.                                 Name = user.Name,
14.                                 PublisherID = ((CUser)user).PublisherID,
15.                                 AuthorID = ((CUser)user).AuthorID,
16.                                 Type = "CUser"
17.                             };
19.                 foreach (var each in query)
20.                 {
21.                     objCUser.ID = each.ID;
22.                     objCUser.Name = each.Name;
23.                     objCUser.UserType = each.UserType;     
24.                     objCUser.PublisherID = each.PublisherID;
25.                     objCUser.AuthorID = each.AuthorID;
26.                     objCUser.Type = each.Type;
27.                 }
28.                 return objCUser;
29.             }
30.             catch (Exception ex)
31.             {
32.                 throw ex;
33.             }
34.         }

 

1. public override void Update(IEntity entity)
2.         {
3.             try
4.             {
5.                 CUser objIEntity = entity as CUser;
6.                 //注意：鉴别器的值不能为空，否则查询出来的为NUll
7.                 var query = from user in theDataContext.GetTable<BaseUser>()
8.                             where user.ID == objIEntity.ID
9.                             select user as CUser;    
10.                 foreach (var each in query)
11.                 {
12.                     each.Name = objIEntity.Name;
13.                 }
14.                 theDataContext.SubmitChanges(ConflictMode.ContinueOnConflict);
15.             }
16.             catch (ChangeConflictException)
17.             {
18.                 theDataContext.ChangeConflicts.ResolveAll(RefreshMode.KeepChanges);
19.                 theDataContext.SubmitChanges();
20.             }
21.         }