Làm thế nào để tổng hợp các số chung trong C#?

Question

thể trùng lặp:
C# generic constraint for only integers

Như bạn có thể thấy trong đoạn mã sau, tôi cần phải tính toán tổng của hai số chung.

public class NumberContainer<T> 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public T Total { get { return ValueA + ValueB; } } 
} 

Tuy nhiên, nó không phải là có thể làm một bổ sung trực tiếp của hai giá trị T, mà kết quả trong các lỗi biên dịch dưới đây: không thể được áp dụng cho toán hạng kiểu

Operator '+' 'T' và 'T'

cho rằng tôi không có ý định sử dụng T cho bất cứ điều gì khác hơn là giá trị các loại đại diện cho số (ngắn, ushort, int, uint, vv), làm thế nào tôi có thể thực hiện tổng? (hiệu quả là yếu tố được xem xét)

Answer 1

Bạn có thể làm điều đó với "chút ma thuật" từ LINQ:

private static readonly Func<T, T, T> adder; 
static NumberContainer() { 
    var p1 = Expression.Parameter(typeof (T)); 
    var p2 = Expression.Parameter(typeof (T)); 
    adder = (Func<T, T, T>)Expression 
     .Lambda(Expression.Add(p1, p2), p1, p2) 
     .Compile(); 
} 
public T Total { get { return adder(ValueA, ValueB); } } 

Hạn chế duy nhất là mã này sẽ biên dịch ngay cả khi NumberContainer được khởi tạo với một loại T mà không hỗ trợ bổ sung; tất nhiên nó sẽ ném một ngoại lệ vào thời gian chạy. Một lợi ích bổ sung là này cần hoạt động với các toán tử do người dùng định nghĩa + do người dùng xác định.

Answer 2

Bạn có thể chỉ định ràng buộc cho T rằng nó phải là cấu trúc và có thể nó thực thi IConvertable, sau đó sử dụng Convert.

public class NumberContainer<T> 
     where T : struct, IConvertible 
    { 
     public T ValueA { get; private set; } 
     public T ValueB { get; private set; } 
     public T Total { 
      get 
      { 
       // do type checking here, then: 

       return (T)Convert.ChangeType(
        Convert.ToDouble((object)ValueA) + 
        Convert.ToDouble((object)ValueB), typeof(T)); 
      } 
     } 
    } 

Tuy nhiên, không có cách nào để Generics đảm bảo rằng T là một số nguyên hoặc kiểu thả nổi lúc biên dịch. Bạn có thể kiểm tra nó trong thời gian chạy, mặc dù, và ném một ngoại lệ.

Answer 3

Ngoài việc sử dụng LINQ, nếu bạn đang ở trên NET 4 này có thể sử dụng dynamic:

static T Add<T>(T x, T y) 
{ 
    dynamic dx = x, dy = y; 
    return dx + dy; 
} 

Trong mẫu mã của bạn này biến thành:

public class NumberContainer<T> where T: struct 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public T Total { get { return ((dynamic)ValueA) + ((dynamic)ValueB); } } 
} 

Cách tiếp cận này doesn' t đảm bảo an toàn mặc dù. Nếu T là một số cấu trúc ngẫu nhiên không hỗ trợ +, bạn sẽ kết thúc với một ngoại lệ (tôi nghĩ).

Answer 4

Bạn có thể điều trị này cũng giống như một lớp cơ sở trừu tượng và lấy được các lớp học cụ thể mà xác định giá trị T và cung cấp việc thực hiện cho Tổng

public abstract class NumberContainer<T> 
    where T: struct 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public abstract T Total(); 
} 

public class IntContainer : NumberContainer<int> 
{ 
    public override int Total() 
    { 
     return ValueA + ValueB; 
    } 
}