Перегрузка операций для созданных шаблонов(C#)

[Mixim]

Необходимо на языке C# реализовать класс "Комплексные числа". Разобрался с основной технологией по этому вопросу(как создать основу шаблона, как заполнить поля в шаблоне), но с перегрузкой операций в шаблоне ничего понять не могу.
Пишу код для перегрузки операции "+":

public static Complex_Digit<Digit_Type> operator+(Complex_Digit<Digit_Type> comp1, Complex_Digit<Digit_Type> comp2)
{
Complex_Digit<Digit_Type> tmp = new Complex_Digit<Digit_Type>();
           tmp.Re = comp1.Re + comp2.Re; //строка 1
tmp.Im = comp1.Im+comp2.Im;  //строка 2
        
           return tmp;
}

В данном коде, Re - действительная часть комплексного числа, Im - мнимая часть. Но почему-то в строчках 1 и 2 компилятор выдает ошибку:"Оператор + не может применяться к операндам типа Digit_Type". Подскажите пожалуйста, что это значит и как избавиться от этой проблемы?

[Altera]

Покажи полный код класса. Компилятор наверное не уверен в том что это числа. Ну т.е.
Нверное шаблон для комплекных чисел - это не очень хорошее рещение. Ну сделай типом вещественные числа и всё будет тип-топ

[Mixim]

Сообщение от Altera

Покажи полный код класса. Компилятор наверное не уверен в том что это числа. Ну т.е.
Нверное шаблон для комплекных чисел - это не очень хорошее рещение. Ну сделай типом вещественные числа и всё будет тип-топ

Необходимо именно реализовать шаблон, типы параметров которого можно задать произвольно(разумеется, они должны быть числами). Код следующий:
public class Complex_Digit< Digit_Type >
{
public Digit_Type Re;
public Digit_Type Im;

public void Push(Digit_Type aRe, Digit_Type aIm)
{
Re = aRe;
Im = aIm;
}

public Complex_Digit<Digit_Type> Pop()
{
return this;
}

public static Complex_Digit<Digit_Type> operator+(Complex_Digit<Digit_Type> any1, Complex_Digit<Digit_Type> any2)
{
Complex_Digit<Digit_Type> tmp = new Complex_Digit<Digit_Type>();
tmp.Re = any1.Re + any2.Re; //компилятору не нравится эта строка и строка ниже
tmp.Im = any1.Im + any2.Im;

return tmp;

}

}

[mrChester]

В вашем случае могло бы помочь ограничение наследования, но в случае арифметики в С# оно не предусмотрено.

Как справиться с арифметикой

Представьте себе, что мы хотим иметь специализированный вариант нашего списка, элементы которого допускали бы операцию сложения и одно из полей которого сохраняло бы сумму всех элементов, добавленных в список. Как задать соответствующее ограничение на класс?

Как уже говорилось, наличие ограничения операции, где можно было бы указать, что над элементами определена операция +, решало бы проблему. Но такого типа ограничений нет. Хуже того, нет и интерфейса INumeric, аналогичного IComparable, определяющего метод сложения Add. Так что нам не может помочь и ограничение наследования.

Вот один из возможных выходов, предлагаемых в такой ситуации. Стратегия следующая: определим абстрактный универсальный класс Calc с методами, выполняющими вычисления. Затем создадим конкретизированных потомков этого класса. В классе, задающем список с суммированием, введем поле класса Calc. При создании экземпляров класса будем передавать фактические типы ключа и элементов, а также соответствующий калькулятор, но уже не как тип, а как аргумент конструктора класса. Этот калькулятор, согласованный с типом элементов, и будет выполнять нужные вычисления. Давайте приступим к реализации этой стратегии. Начнем с определения класса Calc:

public abstract class Calc<T>
{
    public abstract T Add(T a, T b);
    public abstract T Sub(T a, T b);
    public abstract T Mult(T a, T b);
    public abstract T Div(T a, T b);
}

Наш абстрактный универсальный класс определяет четыре арифметические операции. Давайте построим трех его конкретизированных потомков:

public class IntCalc : Calc<int>
{
    public override int Add(int a, int b) { return (a + b);}
    public override int Sub(int a, int b) { return (a - b);}
    public override int Mult(int a, int b) { return (a * b);}
    public override int Div(int a, int b) { return (a / b); }
}
public class DoubleCalc : Calc<double>
{
    public override double Add(double a, double b) 
        {return (a + b);}
    public override double Sub(double a, double b) 
        {return (a - b);}
    public override double Mult(double a, double b) 
        {return (a * b);}
    public override double Div(double a, double b) 
        {return (a / b);}
}
public class StringCalc : Calc<string>
{
    public override string Add(string a, string b) 
        {return (a + b);}
    public override string Sub(string a, string b) 
        {return (a );}
    public override string Mult(string a, string b) 
        {return (a );}
    public override string Div(string a, string b) 
        {return (a);}
}

[mrChester]

Далее

Здесь определяются три разных калькулятора: один - над целочисленными данными, другой - над данными с плавающей точкой, третий - над строковыми данными. В последнем случае определена, по сути, только операция сложения строк (конкатенации).

Теперь нам нужно ввести изменения в ранее созданный класс OneLinkList. Обратите внимание на важный технологический принцип работы с объектными системами. Пусть уже есть нормально работающий класс с нормально работающими клиентами класса. Не следует изменять этот класс. Класс закрыт для изменений. Используйте наследование и открывайте класс-потомок, в который и вносите изменения, учитывающие добавляемую специфику класса. Принцип "Закрыт - Открыт" является одним из важнейших принципов построения программных систем в объектном стиле.

В полном соответствии с этим принципом построим класс SumList - потомок класса OneLinkList. То, что родительский класс является универсальным, ничуть не мешает строить потомка класса, сохраняющего универсальный характер родителя.

public class SumList<K, T> : OneLinkList<K, T> where K :
IComparable<K>

{
Calc<T> calc;
T sum;
public SumList(Calc<T> calc)
{ this.calc = calc; sum = default(T); }
public new void add(K key, T item)
{
Node<K, T> newnode = new Node<K, T>();
if (first == null)
{
first = newnode; cursor = newnode;
newnode.key = key; newnode.item = item;
sum = calc.Add(sum, item);
}
else
{
newnode.next = cursor.next; cursor.next = newnode;
newnode.key = key; newnode.item = item;
sum = calc.Add(sum, item);
}
}
public T Sum()
{return (sum); }
}//SumList

А дальше вода...