Toán tử không thể == được áp dụng cho các loại chung trong C #?

Theo tài liệu của ==nhà điều hành trong MSDN ,

Đối với các loại giá trị được xác định trước, toán tử đẳng thức (==) trả về true nếu các giá trị của toán hạng của nó bằng nhau, sai khác. Đối với các kiểu tham chiếu khác với chuỗi, == trả về true nếu hai toán hạng của nó tham chiếu đến cùng một đối tượng. Đối với loại chuỗi, == so sánh các giá trị của chuỗi. Các loại giá trị do người dùng xác định có thể quá tải toán tử == (xem toán tử). Vì vậy, các loại tham chiếu do người dùng định nghĩa, mặc dù theo mặc định == hoạt động như được mô tả ở trên cho cả các loại tham chiếu được xác định trước và do người dùng xác định.

Vậy tại sao đoạn mã này không biên dịch được?

bool Compare<T>(T x, T y) { return x == y; }

Tôi gặp lỗi Toán tử '==' không thể áp dụng cho toán hạng loại 'T' và 'T' . Tôi tự hỏi tại sao, theo như tôi hiểu ==toán tử được xác định trước cho tất cả các loại?

Chỉnh sửa: Cảm ơn mọi người. Lúc đầu tôi không nhận thấy rằng tuyên bố chỉ nói về các loại tham chiếu. Tôi cũng nghĩ rằng so sánh từng bit được cung cấp cho tất cả các loại giá trị, mà bây giờ tôi biết là không chính xác.

Nhưng, trong trường hợp tôi đang sử dụng một loại tham chiếu, thì ==toán tử sẽ sử dụng so sánh tham chiếu được xác định trước hay nó sẽ sử dụng phiên bản quá tải của toán tử nếu một kiểu được xác định?

Chỉnh sửa 2: Thông qua thử nghiệm và lỗi, chúng tôi đã biết rằng ==toán tử sẽ sử dụng so sánh tham chiếu được xác định trước khi sử dụng loại chung không hạn chế. Trên thực tế, trình biên dịch sẽ sử dụng phương thức tốt nhất mà nó có thể tìm thấy cho đối số loại bị hạn chế, nhưng sẽ không tìm kiếm gì thêm. Ví dụ: mã bên dưới sẽ luôn in true, ngay cả khi Test.test<B>(new B(), new B())được gọi:

class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

"... theo mặc định == hành xử như được mô tả ở trên cho cả loại tham chiếu được xác định trước và do người dùng xác định."

Loại T không nhất thiết là loại tham chiếu, vì vậy trình biên dịch không thể đưa ra giả định đó.

Tuy nhiên, điều này sẽ biên dịch vì nó rõ ràng hơn:

    bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }

Theo dõi câu hỏi bổ sung, "Nhưng, trong trường hợp tôi đang sử dụng loại tham chiếu, thì toán tử == sẽ sử dụng so sánh tham chiếu được xác định trước hay nó sẽ sử dụng phiên bản quá tải của toán tử nếu một loại được xác định?"

Tôi đã nghĩ rằng == trên Generics sẽ sử dụng phiên bản quá tải, nhưng thử nghiệm sau đây cho thấy điều khác. Thú vị ... Tôi muốn biết tại sao! Nếu ai đó biết xin hãy chia sẻ.

namespace TestProject
{
 class Program
 {
    static void Main(string[] args)
    {
        Test a = new Test();
        Test b = new Test();

        Console.WriteLine("Inline:");
        bool x = a == b;
        Console.WriteLine("Generic:");
        Compare<Test>(a, b);

    }


    static bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }
 }

 class Test
 {
    public static bool operator ==(Test a, Test b)
    {
        Console.WriteLine("Overloaded == called");
        return a.Equals(b);
    }

    public static bool operator !=(Test a, Test b)
    {
        Console.WriteLine("Overloaded != called");
        return a.Equals(b);
    }
  }
}

Đầu ra

Nội tuyến: Quá tải == được gọi

Chung:

Bấm phím bất kỳ để tiếp tục . . .

Theo dõi 2

Tôi muốn chỉ ra rằng thay đổi phương pháp so sánh của tôi thành

    static bool Compare<T>(T x, T y) where T : Test
    {
        return x == y;
    }

làm cho toán tử == bị quá tải được gọi. Tôi đoán mà không chỉ định loại (như một nơi ), trình biên dịch không thể suy luận rằng nó nên sử dụng toán tử quá tải ... mặc dù tôi nghĩ rằng nó sẽ có đủ thông tin để đưa ra quyết định ngay cả khi không chỉ định loại.

Như những người khác đã nói, nó sẽ chỉ hoạt động khi T bị ràng buộc là một kiểu tham chiếu. Không có bất kỳ ràng buộc nào, bạn có thể so sánh với null, nhưng chỉ null - và so sánh đó sẽ luôn sai đối với các loại giá trị không null.

Thay vì gọi Equals, tốt hơn là sử dụng một IComparer<T>- và nếu bạn không có thêm thông tin, EqualityComparer<T>.Defaultlà một lựa chọn tốt:

public bool Compare<T>(T x, T y)
{
    return EqualityComparer<T>.Default.Equals(x, y);
}

Ngoài bất cứ điều gì khác, điều này tránh đấm bốc / đúc.

Nói chung, EqualityComparer<T>.Default.Equalsnên thực hiện công việc với bất cứ điều gì thực hiện IEquatable<T>, hoặc có Equalstriển khai hợp lý .

Tuy nhiên, nếu, ==và Equalsđược triển khai khác nhau vì một số lý do, thì công việc của tôi về các toán tử chung sẽ hữu ích; nó hỗ trợ các phiên bản toán tử của (trong số những người khác):

• Bằng nhau (giá trị T1, giá trị T2)
• NotEqual (T value1, T value2)
• GreaterThan (T value1, T value2)
• LessThan (T value1, T value2)
• GreaterThanOrEqual (T value1, T value2)
• LessThanOrEqual (T value1, T value2)

Rất nhiều câu trả lời, và không một câu trả lời nào giải thích TẠI SAO? (mà Giovanni hỏi rõ ràng) ...

.NET generic không hoạt động như các mẫu C ++. Trong các mẫu C ++, độ phân giải quá tải xảy ra sau khi biết các tham số mẫu thực tế.

Trong .NET generic (bao gồm C #), độ phân giải quá tải xảy ra mà không biết các tham số chung thực tế. Thông tin duy nhất mà trình biên dịch có thể sử dụng để chọn hàm cần gọi đến từ các ràng buộc kiểu trên các tham số chung.

Trình biên dịch không thể biết T không thể là một cấu trúc (kiểu giá trị). Vì vậy, bạn phải nói với nó rằng nó chỉ có thể là loại tham chiếu tôi nghĩ:

bool Compare<T>(T x, T y) where T : class { return x == y; }

Đó là bởi vì nếu T có thể là một loại giá trị, có thể có trường hợp x == ysẽ bị hình thành - trong trường hợp khi một loại không có toán tử == được xác định. Điều tương tự sẽ xảy ra cho điều này rõ ràng hơn:

void CallFoo<T>(T x) { x.foo(); }

Điều đó cũng thất bại, bởi vì bạn có thể vượt qua một loại T sẽ không có chức năng foo. C # buộc bạn phải đảm bảo tất cả các loại có thể luôn có chức năng foo. Điều đó được thực hiện bởi mệnh đề where.

Dường như không có ràng buộc lớp:

bool Compare<T> (T x, T y) where T: class
{
    return x == y;
}

Người ta nên nhận ra rằng trong khi classràng buộc Equalstrong ==toán tử kế thừa từ Object.Equals, trong khi đó của cấu trúc ghi đè ValueType.Equals.

Lưu ý rằng:

bool Compare<T> (T x, T y) where T: struct
{
    return x == y;
}

cũng đưa ra lỗi trình biên dịch tương tự.

Vẫn chưa hiểu tại sao việc so sánh toán tử đẳng thức loại giá trị bị từ chối bởi trình biên dịch. Tôi thực sự biết rằng điều này hoạt động:

bool Compare<T> (T x, T y)
{
    return x.Equals(y);
}

Trong trường hợp của tôi, tôi muốn kiểm tra đơn vị toán tử đẳng thức. Tôi cần gọi mã theo các toán tử đẳng thức mà không đặt rõ ràng loại chung. Các lời khuyên cho EqualityComparerkhông hữu ích như phương thức EqualityComparerđược gọi Equalsnhưng không phải là toán tử đẳng thức.

Đây là cách tôi đã làm việc này với các loại chung bằng cách xây dựng một LINQ. Nó gọi đúng mã cho ==và !=toán tử:

/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.Equal(paramA, paramB);
    // compile it
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeEqualityOperator(a, b);
}

/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.NotEqual(paramA, paramB);
    // compile it
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeInequalityOperator(a, b);
}

Có một mục Kết nối MSDN cho điều này ở đây

Câu trả lời của Alex Turner bắt đầu bằng:

Thật không may, hành vi này là theo thiết kế và không có một giải pháp dễ dàng nào cho phép sử dụng == với các tham số loại có thể chứa các loại giá trị.

Nếu bạn muốn đảm bảo các toán tử của loại tùy chỉnh của bạn được gọi, bạn có thể làm như vậy thông qua sự phản chiếu. Chỉ cần lấy loại bằng tham số chung của bạn và truy xuất MethodInfo cho toán tử mong muốn (ví dụ: op_Equality, op_Inequality, op_LessThan ...).

var methodInfo = typeof (T).GetMethod("op_Equality", 
                             BindingFlags.Static | BindingFlags.Public);    

Sau đó thực thi toán tử bằng phương thức Invoke của MethodInfo và truyền vào các đối tượng làm tham số.

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2});

Điều này sẽ gọi toán tử quá tải của bạn và không phải là toán tử được xác định bởi các ràng buộc được áp dụng trên tham số chung. Có thể không thực tế, nhưng có thể có ích để kiểm tra đơn vị toán tử của bạn khi sử dụng lớp cơ sở chung có chứa một vài bài kiểm tra.

Tôi đã viết các chức năng sau đây nhìn vào msDN mới nhất. Nó có thể dễ dàng so sánh hai đối tượng xvà y:

static bool IsLessThan(T x, T y) 
{
    return ((IComparable)(x)).CompareTo(y) <= 0;
}

bool Compare(T x, T y) where T : class { return x == y; }

Ở trên sẽ hoạt động vì == được quan tâm trong trường hợp các loại tham chiếu do người dùng xác định.
Trong trường hợp các loại giá trị, == có thể bị ghi đè. Trong trường hợp đó, "! =" Cũng nên được xác định.

Tôi nghĩ đó có thể là lý do, nó không cho phép so sánh chung bằng cách sử dụng "==".

Các .Equals()công việc cho tôi trong khi TKeylà một loại chung chung.

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}