在实现通用接口C＃的通用类中修改值类型

Question

Hei,

I have been looking but could not find any suitable answer...Maybe point me out.

So I have an interface and a Point class:

interface IDoable<T>{
    void DoSomething<T>(T ) ;
}
class Point<T>:IDoable <T>{ 
    public T x;
    public T y;
    public Point(T x, T y){

        this.x = x;
        this.y = y;
    }
    public void DoSomething<T>(Point<T> p){
        p.x += 10;
        p.y += 10;
    }
}

But it tells me I cannot do that since int cannot be converted to T.

I would need the interface to be able to take any type of Point, whether int, float or double or else and modify the value. Any ideas?

Answer 1

You are trying to add 10 (an integer) to a value of type T . T can be an integer, or a DateTime, or a List, or some other custom class. This means that there is absolutely no guarantee that your T will be able to add itself to an integer.

Unfortunately, there is no way in C# to add a generic type constraint that will restrict the parameter to a type that will support a certain operation.

There are workaround, but they are ugly. ie you could have:

class Point<T>{ ... }

and then have

class IntPoint : Point<int>, IDoable<int> { ... }
class DoublePoint : Point<double>, IDoable<Double> { ... }

Answer 2

First:
The definition of your interface is incorrect. DoSomething should not have its own generic parameter.
It should look like this:

interface IDoable<T>
{
    void DoSomething(T p) ;
}

Second:
There is no interface, common base class or other possibility in .NET that would allow a generic class to use a certain operator.
In other words: You will have to create a class per numeric type you want to use.
If this implementation's DoSomething method should take a *Point as parameter - as per your question - the implementation for int would look like this:

class IntPoint : IDoable<IntPoint>
{ 
    public int x;
    public int y;
    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public void DoSomething(IntPoint p)
    {
        p.x += 10;
        p.y += 10;
    }
}

You would need to create a class DoublePoint for doubles and so on.

You can reduce the amount of repeat code a little bit by creating an abstract base class with an abstract method for the arithmetic operation that would need to be overridden by every derived class.