Существует ли ограничение на С# для типов "реального числа"?

Ответ 1

Вы не можете определить такое ограничение, но вы можете проверить тип во время выполнения. Это не поможет вам делать расчеты.

Если вы хотите выполнять вычисления, то это будет вариант:

class Calculations<T, S> where S: Calculator<T>, new()
{
    Calculator<T> _calculator = new S();

    public T Square(T a)
    {
        return _calculator.Multiply(a, a);
    }

}

abstract class Calculator<T>
{
    public abstract T Multiply(T a, T b);
}

class IntCalculator : Calculator<int>
{
    public override int Multiply(int a, int b)
    {
        return a * b;
    }
}

Аналогичным образом определите a FloatCalculator и любые операции, которые вам нужны. Это не особенно быстро, хотя быстрее, чем конструкция С# 4.0 dynamic.

var calc = new Calculations<int, IntCalculator>();
var result = calc.Square(10);

Побочным эффектом является то, что вы сможете создавать экземпляры Calculator только в том случае, если тип, который вы передаете ему, имеет соответствующую реализацию Calculator<T>, поэтому вам не нужно проверять тип выполнения.

Это в основном то, о чем Хейлсберг упоминал в этом интервью, где обсуждался этот вопрос. Лично мне бы хотелось увидеть какой-то базовый тип:)

Ответ 2

Это очень распространенный вопрос; если вы используете .NET 3.5, для этой поддержки в MiscUtil существует поддержка Operator, который поддерживает встроенные типы и любые пользовательские типы с операторами (включая" снятые" операторы); в частности, это позволяет использовать с дженериками, например:

public static T Sum<T>(this IEnumerable<T> source) {
    T sum = Operator<T>.Zero;
    foreach (T value in source) {
        if (value != null) {
            sum = Operator.Add(sum, value);
        }
    }
    return sum;
}

Или для другого примера; Complex<T>

Ответ 3

Это известная проблема, так как ни один из арифметических классов не приходит из одного класса. Поэтому вы не можете его ограничивать.

Единственное, что вы можете сделать, это

where T : struct

но это не совсем то, что вы хотите.

Вот ссылка на конкретную проблему.

Арифметические типы, такие как int, double, decimal, должны реализовывать IArithmetic <T>

Ответ 4

Вы действительно можете это сделать, хотя решение утомительно для настройки и может смущать разработчиков, которые не знают, почему это было сделано. (поэтому, если вы решите сделать это, запишите его!)...

Создайте две структуры, называемые say MyInt и MyDecimal, которые действуют как фасады для CTS Int32 и десятичных типов ядра (они содержат внутреннее поле соответствующего типа.) Каждый из них должен иметь ctor, который принимает экземпляр Тип Core CTS в качестве входного параметра.

Сделайте каждый из них реализацией пустого интерфейса с именем INumeric

Затем в ваших общих методах создайте ограничение, основанное на этом интерфейсе. Даунсайд, везде, где вы хотите использовать эти методы, вам нужно построить экземпляр соответствующего настраиваемого типа вместо типа Core CTS и передать пользовательский тип методу.

ПРИМЕЧАНИЕ. Кодирование пользовательских структур для правильного эмуляции всех типов основных типов CTS - утомительная часть... Вам необходимо реализовать несколько встроенных интерфейсов CLR (IComparable и т.д.) и перегрузить всю арифметику и логические операторы...

Ответ 5

Вы можете приблизиться к реализации еще нескольких

public class Point<T> where T : struct, IComparable, IFormattable, IConvertible, 
                                IComparable<T>, IEquatable<T> {   
}

Подпись также соответствует DateTime. Я не уверен, что вы сможете указать больше типов из фреймворка. В любом случае это только решает часть проблемы. Для выполнения основных числовых операций вам придется обернуть числовые типы и использовать общие методы вместо стандартных операторов. См. этот вопрос SO для нескольких вариантов.

Ответ 6

Thi может быть вам полезна. Вы должны использовать общий класс для достижения желаемого.

Ответ 7

В настоящее время С# не допускает ограничений типа для типов значений. Я задал близкий вопрос не так давно.

Ограничения типа Enum в С#

Ответ 8

Не будет ли это иметь отдельные классы, реализующие IPoint?

Что-то вроде:

public interface IPoint<T>  
{
    T X { get; set; }
    T Y { get; set; }
}

public class IntegerPoint : IPoint<int>
{

    public int X { get; set; }
    public int Y { get; set; }
}

Так как вычисления будут по-разному отличаться в каждой реализации?

Dan #