Currently I’m coding a Vector class in C# and I’m coming to the point, where I’ve to figure out, how I want to implement a function/method to interpolate between two vectors. The (obvious) and also my first solution was to simply implement it as a method in the vector class itself:
public class Vector3D
{
public static Vector3D LinearInterpolate(Vector3D vector1,
Vector3D vector2, double factor) { ... }
public Vector3D LinearInterpolate(Vector3D other, double factor { ... }
}
(I decided to offer both a static method with two vectors as parameters and one non-static, with only one vector as the parameter)
But then I got the idea to use extension methods (defined in a separate class called e.g. Interpolation for example), since interpolation isn’t really limited to vectors only. So this might be another approach:
public class Vector3D { ... }
public static class Interpolation
{
public static Vector3D LinearInterpolate(this Vector3D vector,
Vector3D other, double factor) { ... }
}
And here is an example showing how one would use the different implementations:
{
var vec1 = new Vector3D(5, 3, 1);
var vec2 = new Vector3D(4, 2, 0);
Vector3D vec3;
vec3 = vec1.LinearInterpolate(vec2, 0.5); //1
vec3 = Vector3D.LinearInterpolate(vec1, vec2, 0.5); //2
//or with extension-methods
vec3 = vec1.LinearInterpolate(vec2, 0.5); //3 (same as 1)
vec3 = Interpolation.LinearInterpolation(vec1, vec2,
0.5); //4
}
I can’t really decide on which design is preferable. Is there a rule of thumb on how to implement methods/functions similar to the one above or is it rather a matter of preference? I really would like to hear your opinions on what’s better and – if possible – why.
16
Maybe it is that I come from Java, but I really don’t like extension methods unless there is a good reason for it.
If you want to reuse the operation code, the solution should be composition. Create an Interpolator that operates over an IEnumerable<double> (unluckily, it seems that C# lacks an equivalent to java.lang.Number, so you can’t make the class generic easily). I don’t think it is a bad idea that your Vector class implements it, too.
For bonus points, make the class an interface that defines the operation and inject an instance of the interface in the object, so you can change the implementation (or even use other types of interpolations, if they match the method signature) at will.
4
Don’t use static classes, static methods (including extension methods) unless you really need them (maybe because of legacy code, or because you extend a .Net framework object).
A in-depth explanation of why static is bad can be found here.
For your Vector3 class, why don’t you simply write a (non-static) class?
public interface ILinearInterpolation
{
void Interpolate(Vector3 a, Vector3 b, double factor);
}
Now you can write an implementation against that interface.
The alternative is to make Interpolate a member method – but you should try to keep the class interface simple, and small. Now, I agree that Vector and Matrix classes are a bit of an exception, because they have a larger inherent feature set than most other classes, as there are a lot of math things that you might need that a vector should be able to do; you mentioned Normalize() as an example in comments. Still, I feel that Interpolate should be in it’s own class.
7
I would use interface and generics (Vector2, Vector4 etc. should be able to use the same implementation) for the interpolation implementation class and then add an extension method to make the usage more clean.
public class Vector3
{
//Implementation
}
public interface IInterpolation<T>
{
T Interpolate(T first, T second, double factor);
}
public class LinearInterpolation<T> : IInterpolation<T>
{
T Interpolate(T first, T second, double factor)
{
return first + ((second - first) * t);
}
}
public static Vector3Helper
{
public static Vector3 LinearInterpolation(this Vector3 vector, Vector3 other, double factor)
{
var interpolation = new LinearInterpolation<Vector3>()
return interpolation.Interpolate(vec1, vec2, 0.5);
}
}
Usage:
Vector3 vec1 = new Vector3(1, 1, 2);
Vector3 vec2 = new Vector3(3, 1, 2);
var interpolation = new LinearInterpolation<Vector3>()
var result interpolation.Interpolate(vec1, vec2, 0.5);
or with the extension method:
var result = vec1.LinearInterpolation(vec2 0.5);
1