Equals Làm thế nào nên chúng ta thực sự được implenting và GetHashCode cho các tổ chức NHibernate

Question

Có rất nhiều câu hỏi và câu trả lời và bài viết cho câu hỏi này có sẵn nhưng theo ý kiến ​​của tôi có vẻ là không thực sự rõ ràng/câu trả lời đúng

Đối với tôi Ayende có tốt nhất việc thực hiện chung cho đến nay mà tôi đã nhìn thấy: http://ayende.com/blog/2500/generic-entity-equality

.... Nhưng đó là từ năm 2007 ....

đây có phải là 'cách tốt nhất' để thực hiện những phương pháp đặc biệt đối với với NHibernate 3.2 có chứa một số khác biệt trong proxy implemen tation cho các phiên bản trước đó?

Answer 1

Đề xuất cá nhân của tôi không phải là để thực hiện các phương pháp này chút nào, bởi vì làm như vậy sẽ tải trong nhiều trường hợp không thực sự cần thiết.

Ngoài ra, nếu bạn không di chuyển thực thể qua các phiên, bạn sẽ không bao giờ cần điều này. Và ngay cả khi bạn làm như vậy, bạn luôn có thể so sánh bằng Id khi cần.

Answer 2

Có!

Bạn nên ghi đè Equals và GetHashCode. Tuy nhiên, bạn không nên đang thực hiện giá trị bình đẳng (Name == other.Name && Age == other.Age), bạn nên làm bình đẳng danh tính!

Nếu không, bạn rất có thể sẽ gặp phải việc so sánh proxy của pháp nhân với thực thể thực và sẽ là khốn khổ để gỡ lỗi. Ví dụ:

public class Blog : EntityBase<Blog> 
{ 
    public virtual string Name { get; set; } 

    // This would be configured to lazy-load. 
    public virtual IList<Post> Posts { get; protected set; } 

    public Blog() 
    { 
     Posts = new List<Post>(); 
    } 

    public virtual Post AddPost(string title, string body) 
    { 
     var post = new Post() { Title = title, Body = body, Blog = this }; 
     Posts.Add(post); 
     return post; 
    } 
} 

public class Post : EntityBase<Post> 
{ 
    public virtual string Title { get; set; } 
    public virtual string Body { get; set; } 
    public virtual Blog Blog { get; set; } 

    public virtual bool Remove() 
    { 
     return Blog.Posts.Remove(this); 
    } 
} 

void Main(string[] args) 
{ 
    var post = session.Load<Post>(postId); 

    // If we didn't override Equals, the comparisons for 
    // "Blog.Posts.Remove(this)" would all fail because of reference equality. 
    // We'd end up be comparing "this" typeof(Post) with a collection of 
    // typeof(PostProxy)! 
    post.Remove(); 

    // If we *didn't* override Equals and *just* did 
    // "post.Blog.Posts.Remove(post)", it'd work because we'd be comparing 
    // typeof(PostProxy) with a collection of typeof(PostProxy) (reference 
    // equality would pass!). 
} 

Dưới đây là một lớp cơ sở ví dụ nếu bạn đang sử dụng int như bạn Id (mà cũng có thể được tóm tắt để any identity type):

public abstract class EntityBase<T> 
    where T : EntityBase<T> 
{ 
    public virtual int Id { get; protected set; } 

    protected bool IsTransient { get { return Id == 0; } } 

    public override bool Equals(object obj) 
    { 
     return EntityEquals(obj as EntityBase<T>); 
    } 

    protected bool EntityEquals(EntityBase<T> other) 
    { 
     if (other == null) 
     { 
      return false; 
     } 
     // One entity is transient and the other is not. 
     else if (IsTransient^other.IsTransient) 
     { 
      return false; 
     } 
     // Both entities are not saved. 
     else if (IsTransient && other.IsTransient) 
     { 
      return ReferenceEquals(this, other); 
     } 
     else 
     { 
      // Compare transient instances. 
      return Id == other.Id; 
     } 
    } 

    // The hash code is cached because a requirement of a hash code is that 
    // it does not change once calculated. For example, if this entity was 
    // added to a hashed collection when transient and then saved, we need 
    // the same hash code or else it could get lost because it would no 
    // longer live in the same bin. 
    private int? cachedHashCode; 

    public override int GetHashCode() 
    { 
     if (cachedHashCode.HasValue) return cachedHashCode.Value; 

     cachedHashCode = IsTransient ? base.GetHashCode() : Id.GetHashCode(); 
     return cachedHashCode.Value; 
    } 

    // Maintain equality operator semantics for entities. 
    public static bool operator ==(EntityBase<T> x, EntityBase<T> y) 
    { 
     // By default, == and Equals compares references. In order to 
     // maintain these semantics with entities, we need to compare by 
     // identity value. The Equals(x, y) override is used to guard 
     // against null values; it then calls EntityEquals(). 
     return Object.Equals(x, y); 
    } 

    // Maintain inequality operator semantics for entities. 
    public static bool operator !=(EntityBase<T> x, EntityBase<T> y) 
    { 
     return !(x == y); 
    } 
}