通用类C＃中的函数专业化

Question

I have a class called PointValue , PointValue and his inheritors can be created only by parametrized constructor that receives one float parameter.

I have a generic class that represents a list of points, template type must inherit from PointValue .

I need that one of the functions would have the ability to add points to the list, because I can't enforce using templates a parametrized constructor. my function gets a pointValueCreator to create the new point.

public class PointList<PointValueT> where PointValueT : PointValue
{
  public void addPointToList(float f, Func<float,PointValueT> pointValueCreator)
  {
     // do something to f and then add a new point: 
     mylist.Add(pointValueCreator(f));
  }
}

So now if I have something like this:

PointList<PointValue> bla = new PointList<PointValue>();

I can call my function like this:

bla.addPointToList(f, (myfloat) => new PointValue(myfloat));

My question is how can I create specialization for addPointToList for my PointValue inheritors, to avoid passing creators.

something like:

public void addPointToList(float f)
{
this.addPointToList(f, (myfloat) => new PointValue(myfloat));
}

I've tried to do it, but the compiler says: Cannot implicitly convert type 'PointValue' to 'PointValueT'. An explicit conversion exists (are you missing a cast?)

I understand that c# doesn't have specialization, if that is the case, maybe some "design" trick can help me ? Let's say I have PointValueA and PointValueB inherting, how can i avoid passing creators for each one of them manually ?

Answer 1

I would have thought that the most basic way to handle this is by passing the factory through the constructor, rather than for each call to addPointToList .

public class PointList<PointValueT> where PointValueT : PointValue
{
    public PointList(Func<float, PointValueT> pointValueCreator)
    {
        this.pointValueCreator = pointValueCreator;
    }
    Func<float, PointValueT> pointValueCreator;
    private List<PointValueT> mylist = new List<PointValueT>();
    public void addPointToList(float f)
    {
        mylist.Add(pointValueCreator(f));
    }
}

This would then be called like this:

PointList<PointValue> bla = new PointList<PointValue>((myfloat) => new PointValue(myfloat));

bla.addPointToList(f);

Answer 2

You cannot specialise generic in C# like you can with templates in C++.

It would be nice to be able to specify constructor arguments in constraints (ie where PointValueT : PointValue, new(float) ), but the language doesn't allow that.

There are a couple of solutions to achieve what you want:

1: use a creator pattern like you're already doing

2: instead of setting the float in the constructor, set it as a property.

public class PointValue
{
    public float Value { get; set; }
}

public class PointList<PointValueT> 
    where PointValueT : PointValue, new()
{
  public void addPointToList(float f)
  {
     // do something to f and then add a new point: 
     mylist.Add(new PointValueT { Value = f });
  }
}

This does mean you can't make your PointValue immutable though.

Answer 3

You can sort of specialize using inheritance

public class PointValueList : PointList<PointValue>
{
    public void addPointToList(float f)
    {
        addPointToList(f, (myfloat) => new PointValue(myfloat));
    }
}

and then on that new inherited or specialized class you can just call

bla.addPointToList(f);

Also depending on your needs you can make the base class abstract and declare

public abstract void addPointToList(float f);

in the base class and then override in derived specialization classes

But yes, as Enigmativity suggested, passing factory through the constructor makes more sense at least with this simple example.