Triển khai IEquatable <T> khi T có thể là IEnumerable <T>

Question

Tôi đã đọc các câu hỏi khác nhau tương tự như của tôi nhưng không ai trong số họ có vẻ giải quyết vấn đề của tôi.

Tôi đã một kiểu như thế này:

class MyObject<T> : IEquatable<MyObject<T>> { // no generic constraints 
    private readonly string otherProp; 
    private readonly T value; 

    public MyObject(string otherProp, T value) 
    { 
    this.otherProp = otherProp; 
    this.value = value; 
    } 

    public string OtherProp { get { return this.otherProp; } } 

    public T Value { get { return this.value; } } 

    // ... 

    public bool Equals(MyObject<T> other) 
    { 
    if (other == null) 
    { 
     return false; 
    } 

    return this.OtherProp.Equals(other.OtherProp) && this.Value.Equals(other.Value); 
    } 
} 

Khi T là một vô hướng như MyObject<int> bình đẳng hoạt động chính xác, nhưng khi tôi định nghĩa một cái gì đó giống như MyObject<IEnumerable<int>> bình đẳng thất bại.

Lý do là khi T là IEnumerable<T> Tôi nên gọi this.Value.SequenceEqual(other.Value).

Xử lý sự khác biệt này bloats Equals(MyObject<T>) với quá LOC loại kiểm tra và phản ánh (đối với tôi, dẫn đến vi phạm SOLID/SRP).

Tôi không thể tìm thấy trường hợp cụ thể này trong nguyên tắc MSDN, vì vậy nếu có ai đó đã gặp sự cố này; nó sẽ là tuyệt vời nếu kiến ​​thức này có thể được chia sẻ.

Edit: Alternative

Để K.I.S.S., tôi đang tự hỏi để làm một cái gì đó tương tự:

class MyObject<T> : IEquatable<MyObject<T>> { 
    private readonly IEnumerable<T> value; 

    // remainder omitted 
} 

Bằng cách này, thực hiện Equal sẽ có rất nhiều đơn giản. Và khi tôi chỉ cần một giá trị tôi đã có một bộ sưu tập gồm 1 mục. Rõ ràng T sẽ không được liệt kê (nhưng cấu trúc dữ liệu là riêng tư nên không có vấn đề gì).

Answer 1

Bạn có thể có của bạn MyObject<T> lấy một comparer bình đẳng cho loại hình của bạn T và sử dụng rằng:

class MyObject<T> : IEquatable<MyObject<T>> 
{ 
    private readonly IEqualityComparer<T> comparer; 
    public MyObject(string otherProp, T value, IEqualityComparer<T> comparer) 
    { 
     this.comparer = comparer; 
    } 
    public MyObject(string otherProp, T value) 
     : this(otherProp, value, EqualityComparer<T>.Default) 
    { 
    } 

    public bool Equals(MyObject<T> other) 
    { 
     return OtherProp.Equals(other.OtherProp) && comparer.Equals(this.Value, other.Value); 
    } 
} 

Sau đó cho IEnumerable<T> bạn có thể sử dụng một Comparer mà so sánh trình tự thay vì tham chiếu.Bạn có thể muốn sử dụng các phương pháp nhà máy để tạo các đối tượng của mình để đảm bảo cùng một loại so sánh được sử dụng cho cùng một số T để đảm bảo sự bình đẳng vẫn là đối xứng.

Answer 2

Không cần phản ánh. Một lựa chọn là để kiểm tra xem giá trị là IEnumerable hay không trong phương pháp Equals của bạn:

IEnumerable e = other.Value as IEnumerable; 

if(e != null){ 
// use SequenceEqual 
}else{ 
// use Equals 
} 

Answer 3

Trong trường hợp khi T là IEnumerable<T>, mã của bạn so sánh hai tài liệu tham khảo của IEnumerable<T> và, tất nhiên, những tài liệu tham khảo có thể không bằng nhau. Trên thực tế, bạn sẽ nhận được hành vi này, khi T sẽ là bất kỳ loại tham chiếu nào mà không có phương thức Equals bị ghi đè.

Nếu bạn không muốn so sánh các tham chiếu ở đây, bạn nên viết mã, sẽ so sánh các chuỗi này theo nội dung của chúng. Tuy nhiên, bạn nên lưu ý, chuỗi đó có thể là vô tận.

Answer 4

đây là trường hợp bạn cần trợ giúp của lớp trợ giúp, loại MyObject của bạn có thể sử dụng EqualityChecker riêng lẻ.

Tôi muốn nói triển khai mẫu chiến lược với phương pháp nhà máy tĩnh sẽ đơn giản hóa thiết kế của bạn.

một cái gì đó như dưới đây

class MyObject<T> : IEquatable<MyObject<T>> 
{ // no generic constraints 
    private readonly string otherProp; 
    private readonly T value; 

    public MyObject(string otherProp, T value) 
    { 
     this.otherProp = otherProp; 
     this.value = value; 
    } 

    public string OtherProp { get { return this.otherProp; } } 

    public T Value { get { return this.value; } } 

    // ... 

    public bool Equals(MyObject<T> other) 
    { 
     if (other == null) 
     { 
      return false; 
     } 

    var cheker = EqualityChekerCreator<T>.CreateEqualityChecker(other.Value); 

    if (cheker != null) 
     return cheker.CheckEquality(this.Value, other.value); 

     return this.OtherProp.Equals(other.OtherProp) && this.Value.Equals(other.Value); 
    } 
} 

public static class EqualityChekerCreator<T> 
{ 
    private static IEqualityCheker<T> checker; 

    public static IEqualityCheker<T> CreateEqualityChecker(T type) 
    { 
     var currenttype = type as IEnumerable<T>; 

     if(currenttype!=null) 
      checker = new SequenceEqualityChecker<T>(); 

     return checker; 
    } 
} 

public interface IEqualityCheker<in T> 
{ 
    bool CheckEquality(T t1, T t2); 
} 

public class SequenceEqualityChecker <T> : IEqualityCheker<T> 
{ 
    #region Implementation of IEqualityCheker<in T> 

    public bool CheckEquality(T t1, T t2) 
    { 
     // implement method here; 
    } 

    #endregion 
}