第一章(2):Nettiers实体层,抽像类EntityBaseCore

1.         ///EntityBaseCore:所有数据库表实体类的父类(抽像类),定义了所有实体类必须要实现的行为
2.         /// <summary>
3.         /// The base object for each database table entity.
4.         /// </summary>
5.         ///继承接口IEntity(见第一章), INotifyPropertyChanged(向客户端发出某一属性值已更改的通知), IDataErrorInfo(提供用户界面可以绑定的自定义错误信息), IDeserializationCallback(示在完成整个对象图形的反序列化时通知类)
6.         [Serializable]//实体为可序列化
7.         public abstract partial class EntityBaseCore : IEntity, INotifyPropertyChanged, IDataErrorInfo, IDeserializationCallback
8.         {
9.                 #region Constructors
11.                 /// <summary>
12.                 /// Initializes a new instance of the <see cref="T:EntityBaseCore"/> class.
13.                 /// </summary>
14.                 protected EntityBaseCore()
15.                 {
16.                 }
18.               #endregion
20.             /// <summary>
21.             /// Determines whether the entity is being tracked by the Locator.
22.             /// </summary>
23.                 [NonSerialized]
24.                 private bool isEntityTracked = false;
26.                 /// <summary>
27.                 /// Suppresses Entity Events from Firing,
28.                 /// useful when loading the entities from the database.
29.                 /// </summary>
30.             [NonSerialized]
31.                 private bool suppressEntityEvents = false;
34.                 /// <summary>
35.                 ///  Used by in place editing of databinding features for new inserted row.
36.                 /// Indicates that we are in the middle of an IBinding insert transaction.
37.                 /// </summary>
38.                 [NonSerialized]
39.                 protected bool bindingIsNew = true;
41.                 ///<summary>
42.                 ///  The actual hashcode of the entity.
43.                 ///</summary>
44.                 private string entityHashCode;
46.                 /// <summary>
47.                 ///        The name of the underlying database table.
48.                 /// </summary>
49.                 public abstract string TableName { get;}
51.                 /// <summary>
52.                 ///                The name of the underlying database table's columns.
53.                 /// </summary>
54.                 /// <value>A string array that holds the columns names.</value>
55.                 public abstract string[] TableColumns {get;}
57.                 //private bool _isDeleted = false;
58.                 /// <summary>
59.                 ///         True if object has been <see cref="MarkToDelete"/>. ReadOnly.
60.                 /// </summary>
61.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
62.                 public virtual bool IsDeleted
63.                 {
64.                         get { return this.EntityState == EntityState.Deleted; }
65.                 }
67.                 //private bool _isDirty = false;
68.                 /// <summary>
69.                 ///                Indicates if the object has been modified from its original state.
70.                 /// </summary>
71.                 /// <remarks>True if object has been modified from its original state; otherwise False;</remarks>
72.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
73.                 public virtual bool IsDirty
74.                 {
75.                         get { return this.EntityState != EntityState.Unchanged; }
76.                 }
79.                 //private bool _isNew = true;
80.                 /// <summary>
81.                 ///                Indicates if the object is new.
82.                 /// </summary>
83.                 /// <remarks>True if objectis new; otherwise False;</remarks>
84.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
85.                 public virtual bool IsNew
86.                 {
87.                         get { return this.EntityState == EntityState.Added; }
88.                         set { this.EntityState = EntityState.Added; }
89.                 }
91.                 //private EntityState state = EntityState.Unchanged ;
92.                 /// <summary>
93.                 ///                Indicates state of object
94.                 /// </summary>
95.                 /// <remarks>0=Unchanged, 1=Added, 2=Changed</remarks>
96.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
97.                 public abstract EntityState EntityState { get; set; }
99.                 /// <summary>
100.                 /// Accepts the changes made to this object.
101.                 /// </summary>
102.                 /// <remarks>
103.                 /// After calling this method <see cref="IsDirty"/> and <see cref="IsNew"/> are false. <see cref="IsDeleted"/> flag remain unchanged as it is handled by the parent List.
104.                 /// </remarks>
105.                 public virtual void AcceptChanges()
106.                 {
107.                         this.bindingIsNew = false;
108.                         EntityState = EntityState.Unchanged;
109.                         OnPropertyChanged(string.Empty);
110.                 }
113.                 ///<summary>
114.                 ///  Revert all changes and restore original values.  To be implemented in concrete class.
115.                 ///</summary>
116.                 public abstract void CancelChanges();
119.                 ///<summary>
120.                 ///   Marks entity to be deleted.
121.                 ///</summary>
122.                 public virtual void MarkToDelete()
123.                 {
125.                         if (this.EntityState != EntityState.Added)
126.                                 this.EntityState = EntityState.Deleted ;
127.                 }
129.                 ///<summary>
130.                 ///   Remove the "isDeleted" mark from the entity.
131.                 ///</summary>
132.                 public virtual void RemoveDeleteMark()
133.                 {
134.                         if (this.EntityState != EntityState.Added)
135.                         {
136.                                 this.EntityState = EntityState.Changed ;
137.                         }
138.                 }
140.                 /// <summary>
141.         /// Gets or sets the parent collection.
142.         /// </summary>
143.         /// <value>The parent collection.</value>
144.                 [XmlIgnore]
145.                 public abstract object ParentCollection{get;set;}
147.                 #region Common Columns
148.                 #endregion
150.                 /// <summary>
151.                 /// Object that contains data to associate with this object
152.                 /// </summary>
153.                 [NonSerialized]
154.                 private object tag;
156.                 /// <summary>
157.                 ///     Gets or sets the object that contains supplemental data about this object.
158.                 /// </summary>
159.                 /// <value>Object</value>
160.                 [System.ComponentModel.Bindable(false)]//指定成员不用于绑定
161.                 [LocalizableAttribute(false)]
162.                 [DescriptionAttribute("Object containing data to be associated with this object")]
163.                 public virtual object Tag
164.                 {
165.                         get
166.                         {
167.                                 return this.tag;
168.                         }
169.                         set
170.                         {
171.                                 if (this.tag == value)
172.                                         return;
174.                                 this.tag = value;
175.                         }
176.                 }
178.                 /// <summary>
179.                 /// Determines whether this entity is being tracked.
180.                 /// </summary>
181.                 [System.ComponentModel.Bindable(false)]
182.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
183.                 public bool IsEntityTracked
184.                 {
185.                         get
186.                         {
187.                                 return isEntityTracked;
188.                         }
189.                         set
190.                         {
191.                                 isEntityTracked = value;
192.                         }
193.                 }
196.                 /// <summary>
197.                 /// Determines whether this entity is to suppress events while set to true.
198.                 /// </summary>
199.                 [System.ComponentModel.Bindable(false)]
200.                 [BrowsableAttribute(false), XmlIgnoreAttribute()]
201.                 public bool SuppressEntityEvents
202.                 {
203.                         get
204.                         {
205.                                 return suppressEntityEvents;
206.                         }
207.                         set
208.                         {
209.                                 suppressEntityEvents = value;
210.                         }
211.                 }
213.                 ///<summary>
214.                 /// Provides the tracking key for the <see cref="EntityLocator"/>
215.                 ///</summary>
216.                 [XmlIgnoreAttribute(), BrowsableAttribute(false)]
217.                 public abstract string EntityTrackingKey {        get; set; }
219.                 ///<summary>
220.                 /// Provides a unique HashCode throughout the lifetime of the entity.
221.                 ///</summary>
222.                 public override int GetHashCode()
223.                 {
224.                         if (entityHashCode == null)
225.                                 entityHashCode = Guid.NewGuid().ToString();
227.                         return entityHashCode.GetHashCode();
228.                 }
230.                 #region INotifyPropertyChanged Members
232.                 /// <summary>
233.                 /// Event to indicate that a property has changed.
234.                 /// </summary>
235.                 [field:NonSerialized]
236.                 public event PropertyChangedEventHandler PropertyChanged;
238.                 /// <summary>
239.                 /// Called when a property is changed
240.                 /// </summary>
241.                 /// <param name="propertyName">The name of the property that has changed.</param>
242.                 protected virtual void OnPropertyChanged(string propertyName)
243.                 {
244.                         if (!suppressEntityEvents)
245.                         {
246.                                 OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
247.                         }
248.                 }
250.                 /// <summary>
251.                 /// Called when a property is changed
252.                 /// </summary>
253.                 /// <param name="e">PropertyChangedEventArgs</param>
254.                 protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
255.                 {
256.                         if (!suppressEntityEvents)
257.                         {
258.                                 //Validate the property
259.                          ValidationRules.ValidateRules(e.PropertyName);
261.                                 if (null != PropertyChanged)
262.                                 {
263.                                         PropertyChanged(this, e);
264.                                 }
265.                         }
266.                 }
268.                 #endregion
270.                 #region IDataErrorInfo Members
272.                 /// <summary>
273.                 /// Gets an error message indicating what is wrong with this object.
274.                 /// </summary>
275.                 /// <value></value>
276.                 /// <returns>An error message indicating what is wrong with this object. The default is an empty string ("").</returns>
277.                 public string Error
278.                 {
279.                         get
280.                         {
281.                                 string errorDescription = string.Empty;
282.                                 if (!IsValid)
283.                                 {
284.                                         errorDescription = ValidationRules.GetBrokenRules().ToString();
285.                                 }
286.                                 return errorDescription;
287.                         }
288.                 }
290.                 /// <summary>
291.                 /// Gets the <see cref="T:String"/> with the specified column name.
292.                 /// </summary>
293.                 /// <value></value>
294.                 public string this[string columnName]
295.                 {
296.                         get
297.                         {
298.                                 string errorDescription = string.Empty;
299.                                 if (!IsValid)
300.                                 {
301.                                          errorDescription = ValidationRules.GetBrokenRules().GetPropertyErrorDescriptions(columnName);
302.                                 }
303.                                 return errorDescription;
304.                         }
305.                 }
307.               #endregion
309.               #region Validation
311.                 [NonSerialized]
312.              private Validation.ValidationRules _validationRules;
314.                 /// <summary>
315.                 /// Returns the list of <see cref="Validation.ValidationRules"/> associated with this object.
316.                 /// </summary>
317.                 [XmlIgnoreAttribute()]
318.                 protected Validation.ValidationRules ValidationRules
319.                 {
320.                         get
321.                         {
322.                                 if (_validationRules == null)
323.                                 {
324.                                         _validationRules = new Validation.ValidationRules(this);
326.                                         //lazy init the rules as well.
327.                                         AddValidationRules();
328.                                 }
330.                                 return _validationRules;
331.                         }
332.                 }
334.                 /// <summary>
335.                 /// Assigns validation rules to this object.
336.                 /// </summary>
337.                 /// <remarks>
338.                 /// This method can be overridden in a derived class to add custom validation rules.
339.                 ///</remarks>
340.                 protected virtual void AddValidationRules()
341.                 {
343.                 }
345.                 /// <summary>
346.                 /// Returns a list of all the validation rules that failed.
347.                 /// </summary>
348.                 /// <returns><see cref="Validation.BrokenRulesList" /></returns>
349.                 [XmlIgnoreAttribute()]
350.                 public virtual Validation.BrokenRulesList BrokenRulesList
351.                 {
352.                         get
353.                         {
354.                                 return ValidationRules.GetBrokenRules();
355.                         }
356.                 }
358.                 /// <summary>
359.                 /// Adds a rule to the list of validated rules.
360.                 /// </summary>
361.                 /// <param name="handler">The method that implements the rule.</param>
362.                 /// <param name="propertyName">
363.                 /// The name of the property on the target object where the rule implementation can retrieve
364.                 /// the value to be validated.
365.                 /// </param>
366.                 public void AddValidationRuleHandler(Validation.ValidationRuleHandler handler, String propertyName)
367.                 {
368.                    ValidationRules.AddRule(handler, propertyName);
369.                 }
371.                 /// <summary>
372.                 /// Adds a rule to the list of validated rules.
373.                 /// </summary>
374.                 /// <remarks>
375.                 /// </remarks>
376.                 /// <param name="handler">The method that implements the rule.</param>
377.                 /// <param name="args">
378.                 /// A <see cref="Validation.ValidationRuleArgs"/> object specifying the property name and other arguments
379.                 /// passed to the rule method
380.                 /// </param>
381.                 public void AddValidationRuleHandler(Validation.ValidationRuleHandler handler, Validation.ValidationRuleArgs args)
382.                 {
383.                     ValidationRules.AddRule(handler, args);
384.                 }
386.                 /// <summary>
387.                 /// Returns <see langword="true" /> if the object is valid,
388.                 /// <see langword="false" /> if the object validation rules that have indicated failure.
389.                 /// </summary>
390.                 [Browsable(false)]
391.                 public virtual bool IsValid
392.                 {
393.                         get
394.                         {
395.                                 Validate();
396.                                 return ValidationRules.IsValid;
397.                         }
398.                 }
400.                 /// <summary>
401.                 /// Force this object to validate itself using the assigned business rules.
402.                 /// </summary>
403.                 /// <remarks>Validates all properties.</remarks>
404.                 public void Validate()
405.                 {
406.                         ValidationRules.ValidateRules();
407.                 }
409.                 /// <summary>
410.                 /// Force the object to validate itself using the assigned business rules.
411.                 /// </summary>
412.                 /// <param name="propertyName">Name of the property to validate.</param>
413.                 public void Validate(string propertyName)
414.                 {
415.                         ValidationRules.ValidateRules(propertyName);
416.                 }
418.                 /// <summary>
419.                 /// Force the object to validate itself using the assigned business rules.
420.                 /// </summary>
421.                 /// <param name="column">Column enumeration representing the column to validate.</param>
422.                 public void Validate(System.Enum column)
423.                 {
424.                         Validate(column.ToString());
425.                 }
426.               #endregion
428.                 #region IDeserializationCallback Members
430.                         /// <summary>
431.                         /// Runs when the entire object graph has been deserialized.
432.                         /// </summary>
433.                         /// <param name="sender">The object that initiated the callback. The functionality for this parameter is not currently implemented.</param>
434.                         public void OnDeserialization(object sender)
435.                         {
436.                                 if(!suppressEntityEvents)
437.                                 {
438.                                         ValidationRules.Target = this;
439.                                         AddValidationRules();
440.                                 }
441.                         }
443.                 #endregion
445.         }